# HG changeset patch # User maxzanoni76 # Date 1334132826 -3600 # Node ID 8b6102e2a9b0898f6e5d69420a37e9071efe58bf Armadillo Library diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/CMakeLists.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/CMakeLists.txt Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,378 @@ + +# Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +# Copyright (C) 2008-2011 Conrad Sanderson +# Copyright (C) 2011 Clement Creusot +# +# This file is part of the Armadillo C++ library. +# It is provided without any warranty of fitness +# for any purpose. You can redistribute this file +# and/or modify it under the terms of the GNU +# Lesser General Public License (LGPL) as published +# by the Free Software Foundation, either version 3 +# of the License or (at your option) any later version. +# (see http://www.opensource.org/licenses for more info) + +cmake_minimum_required(VERSION 2.6 FATAL_ERROR) + +set(ARMA_MAJOR 2) +set(ARMA_MINOR 4) +set(ARMA_PATCH 4) + +message(STATUS "Configuring Armadillo ${ARMA_MAJOR}.${ARMA_MINOR}.${ARMA_PATCH}") + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/build_aux/cmake/Modules/") + +include(CheckIncludeFileCXX) +include(CheckLibraryExists) +include(FindBoost) +include(ARMA_CheckProto) +include(ARMA_CheckMathProto) + +project(armadillo CXX) + +#CMAKE_REQUIRED_FLAGS = string of compile command line flags +#CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) +#CMAKE_REQUIRED_LIBRARIES = list of libraries to link + + +set(ARMA_USE_LAPACK false) +set(ARMA_USE_BLAS false) +set(ARMA_USE_ATLAS false) +set(ARMA_USE_BOOST false) +set(ARMA_USE_WRAPPER true ) + + +if(WIN32) + message(STATUS "") + message(STATUS "WARNING:") + message(STATUS "Automatic installation is currently not available for this platform.") + message(STATUS "Please use the manual installation, as described in the README.txt file.") + message(STATUS "You can also use the 'include' folder directly, but you may want to edit") + message(STATUS "'include/armadillo_bits/config.hpp' if you have LAPACK installed.") + message(STATUS "") +endif() + + + +# +# Find LAPACK and BLAS libraries, or their optimised versions +# + +if(APPLE) + set(ARMA_OS macos) + + set(ARMA_USE_LAPACK true) + set(ARMA_USE_BLAS true) + + # Under MacOS, the current version of ARMA_FindCLAPACK can get confused between + # two incompatible versions of "clapack.h" (one provided by the system and one + # provided by ATLAS). As such, use of ATLAS under MacOS is disabled for now. + +else() + set(ARMA_OS unix) + + include(ARMA_FindMKL) + include(ARMA_FindACMLMP) + include(ARMA_FindACML) + + message(STATUS "MKL_FOUND = ${MKL_FOUND}") + message(STATUS "ACMLMP_FOUND = ${ACMLMP_FOUND}") + message(STATUS "ACML_FOUND = ${ACML_FOUND}") + + if(MKL_FOUND OR ACMLMP_FOUND OR ACML_FOUND) + + set(ARMA_USE_BLAS true) + set(ARMA_USE_LAPACK true) + + message(STATUS "*** If the MKL or ACML libraries are installed in a non-standard location,") + message(STATUS "*** make sure the run-time linker can find them.") + message(STATUS "*** On Linux systems this can be done by editing /etc/ld.so.conf") + message(STATUS "*** or modifying the LD_LIBRARY_PATH environment variable.") + message(STATUS "*** On systems with SELinux enabled (e.g. Fedora, RHEL),") + message(STATUS "*** you may need to change the SELinux type of all MKL/ACML libraries") + message(STATUS "*** to fix permission problems that may occur during run-time.") + message(STATUS "*** See README.txt for more information") + + else() + + include(ARMA_FindLAPACK) + include(ARMA_FindBLAS) + include(ARMA_FindCLAPACK) + include(ARMA_FindCBLAS) + + message(STATUS "LAPACK_FOUND = ${LAPACK_FOUND}") + message(STATUS "BLAS_FOUND = ${BLAS_FOUND}") + message(STATUS "CLAPACK_FOUND = ${CLAPACK_FOUND}") + message(STATUS "CBLAS_FOUND = ${CBLAS_FOUND}") + + if(LAPACK_FOUND) + set(ARMA_USE_LAPACK true) + endif() + + if(BLAS_FOUND) + set(ARMA_USE_BLAS true) + endif() + + if(CLAPACK_FOUND AND CBLAS_FOUND) + message(STATUS "CLAPACK_INCLUDE_DIR = ${CLAPACK_INCLUDE_DIR}") + message(STATUS "CBLAS_INCLUDE_DIR = ${CBLAS_INCLUDE_DIR}") + if(${CLAPACK_INCLUDE_DIR} STREQUAL ${CBLAS_INCLUDE_DIR}) + set(ARMA_USE_ATLAS true) + set(ARMA_ATLAS_INCLUDE_DIR ${CLAPACK_INCLUDE_DIR}) + endif() + endif() + + endif() + +endif() + + +if(MKL_FOUND OR ACMLMP_FOUND OR ACML_FOUND) + + if(MKL_FOUND) + set(ARMA_LIBS ${ARMA_LIBS} ${MKL_LIBRARIES}) + + if(ACMLMP_FOUND OR ACML_FOUND) + message(STATUS "*** Intel MKL as well as AMD ACML libraries were found.") + message(STATUS "*** Using only the MKL library to avoid linking conflicts.") + message(STATUS "*** If you wish to use ACML instead, please link manually with") + message(STATUS "*** acml or acml_mp instead of the armadillo run-time component.") + message(STATUS "*** Alternatively, remove MKL from your system and rerun") + message(STATUS "*** Armadillo's configuration using ./configure") + endif() + + else() + + if(ACMLMP_FOUND) + set(ARMA_LIBS ${ARMA_LIBS} ${ACMLMP_LIBRARIES}) + + message(STATUS "*** Both single-core and multi-core ACML libraries were found.") + message(STATUS "*** Using only the multi-core library to avoid linking conflicts.") + else() + if(ACML_FOUND) + set(ARMA_LIBS ${ARMA_LIBS} ${ACML_LIBRARIES}) + endif() + endif() + + endif() + +else() + + if(ARMA_USE_BLAS STREQUAL true) + set(ARMA_LIBS ${ARMA_LIBS} ${BLAS_LIBRARIES}) + endif() + + if(ARMA_USE_LAPACK STREQUAL true) + set(ARMA_LIBS ${ARMA_LIBS} ${LAPACK_LIBRARIES}) + endif() + + if(ARMA_USE_ATLAS STREQUAL true) + set(ARMA_LIBS ${ARMA_LIBS} ${CBLAS_LIBRARIES}) + set(ARMA_LIBS ${ARMA_LIBS} ${CLAPACK_LIBRARIES}) + endif() + +endif() + + +if(APPLE) + set(ARMA_LIBS ${ARMA_LIBS} "-framework Accelerate") # or "-framework accelerate" ? + message(STATUS "MacOS X detected. Added '-framework Accelerate' to compiler flags") +endif() + +message(STATUS "*** ") +message(STATUS "*** The Armadillo run-time library component will be an alias for the following libraries:") +message(STATUS "*** ARMA_LIBS = ${ARMA_LIBS}") +message(STATUS "*** ") + +find_package(Boost) + +if(Boost_FOUND) + + message(STATUS "Boost_MAJOR_VERSION = ${Boost_MAJOR_VERSION}") + message(STATUS "Boost_MINOR_VERSION = ${Boost_MINOR_VERSION}") + + if(Boost_MAJOR_VERSION GREATER 0) + if(Boost_MINOR_VERSION GREATER 33) + set(ARMA_USE_BOOST true) + message(STATUS "Boost_INCLUDE_DIR = ${Boost_INCLUDE_DIR}") + endif() + endif() + +endif() + +if(ARMA_USE_BOOST STREQUAL false) + message(STATUS "Boost libraries either not found or their version is too low (version 1.34 or later is good).") + message(STATUS "( It's possible that CMake didn't find the particular version of Boost you may have. )") + message(STATUS "( If that's the case, please edit include/armadillo_bits/config.hpp manually. )") +endif() + + +# If Boost libraries were found, explicitly check if Boost's date_time library is also present. +# This is due to the non-standard packaging of Boost libraries on Debian and Ubuntu systems, +# where certain individual Boost libraries are packaged separately. + +if(ARMA_USE_BOOST STREQUAL true) + set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${Boost_INCLUDE_DIR}) + CHECK_INCLUDE_FILE_CXX("boost/date_time/posix_time/posix_time.hpp" ARMA_USE_BOOST_DATE) +endif() + +ARMA_CHECK_MATH_PROTO("isfinite" "std" "cmath" ARMA_HAVE_STD_ISFINITE) +ARMA_CHECK_MATH_PROTO("isinf" "std" "cmath" ARMA_HAVE_STD_ISINF) +ARMA_CHECK_MATH_PROTO("isnan" "std" "cmath" ARMA_HAVE_STD_ISNAN) +ARMA_CHECK_MATH_PROTO("log1p" "" "cmath" ARMA_HAVE_LOG1P) + +ARMA_CHECK_PROTO("snprintf" "std" "cstdio" ARMA_HAVE_STD_SNPRINTF) +ARMA_CHECK_PROTO("gettimeofday" "" "sys/time.h" ARMA_HAVE_GETTIMEOFDAY) + + +message(STATUS "Generating 'include/armadillo_bits/config.hpp'") +configure_file(include/armadillo_bits/config.hpp.cmake include/armadillo_bits/config.hpp) + +message(STATUS "Generating 'examples/Makefile'") +configure_file(examples/Makefile.cmake examples/Makefile) + + +if(ARMA_USE_BOOST STREQUAL true) + include_directories(include ${Boost_INCLUDE_DIR}) +else() + include_directories(include) +endif() + + +## For any library that is not in a default location, +## embed its path into the Armadillo runtime library. +## Examples of default locations are "/lib", "/usr/lib", +## or as specified in "/etc/ld.so.conf". +## +## Path embedding is not recommended unless you know +## what you're doing. It might be better to add the +## path to the "/etc/ld.so.conf" file and then run "ldconfig". +## +#set(CMAKE_SKIP_BUILD_RPATH FALSE) +#set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) +#set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) + + +add_library( armadillo SHARED src/wrap_libs ) +target_link_libraries( armadillo ${ARMA_LIBS} ) + +set_target_properties(armadillo PROPERTIES VERSION ${ARMA_MAJOR}.${ARMA_MINOR}.${ARMA_PATCH} SOVERSION 2) + + + +################################################################################ +# INSTALL CONFIGURATION + + +# As Red Hat Enterprise Linux (and related systems such as Fedora) +# does not search /usr/local/lib by default, we need to place the +# library in either /usr/lib or /usr/lib64 + +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "/usr") +endif() + +# Allow for the "lib" directory to be specified on the command line +if(NOT INSTALL_LIB_DIR) + set(INSTALL_LIB_DIR "lib") + if(UNIX AND NOT APPLE) # I don't know how Mac OS handles 64 bit systems + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + message(STATUS "Detected 64 bit system") + if(IS_DIRECTORY "${CMAKE_INSTALL_PREFIX}/lib64") + unset(INSTALL_LIB_DIR) + set(INSTALL_LIB_DIR "lib64") + endif() + endif() + endif() +endif() + +# Allow for the "include" directory to be specified on the command line + +if(NOT INSTALL_INCLUDE_DIR) + set(INSTALL_INCLUDE_DIR "include") +endif() + +# We use data dir to store files shared with other programs +# like the ArmadilloConfig.cmake file. +if(NOT INSTALL_DATA_DIR) + set(INSTALL_DATA_DIR "share") +endif() + +# Make relative paths absolute so we can write them in Config.cmake files +foreach(p LIB INCLUDE DATA) + set(var INSTALL_${p}_DIR) + if(NOT IS_ABSOLUTE "${${var}}") + set(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}") + endif() +endforeach() + +message(STATUS "CMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}") +message(STATUS "INSTALL_LIB_DIR = ${INSTALL_LIB_DIR}" ) +message(STATUS "INSTALL_INCLUDE_DIR = ${INSTALL_INCLUDE_DIR}" ) +message(STATUS "INSTALL_DATA_DIR = ${INSTALL_DATA_DIR}" ) + + +# Note that the trailing / character in "include/" is critical + +install(DIRECTORY include/ DESTINATION ${INSTALL_INCLUDE_DIR} +PATTERN ".svn" EXCLUDE +PATTERN "*.cmake" EXCLUDE +PATTERN "*~" EXCLUDE +PATTERN "*orig" EXCLUDE +) + +install(TARGETS armadillo + DESTINATION ${INSTALL_LIB_DIR} + EXPORT ArmadilloLibraryDepends) + +# Export the package for use from the build-tree +# (this registers the build-tree with a global CMake-registry) +if(CMAKE_VERSION VERSION_GREATER "2.7") + export(PACKAGE armadillo) +endif() + +## LOCAL FILES +# Create ArmadilloConfig.cmake file for the use from the build tree +set(ARMADILLO_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}") +set(ARMADILLO_LIB_DIR "${PROJECT_BINARY_DIR}") +set(ARMADILLO_CMAKE_DIR "${PROJECT_BINARY_DIR}") + + +message(STATUS "Generating '${PROJECT_BINARY_DIR}/ArmadilloConfig.cmake'") +# copy/change config and configVersion file (modify only the @xyz@ variables) +configure_file(build_aux/cmake/InstallFiles/ArmadilloConfig.cmake.in + "${PROJECT_BINARY_DIR}/ArmadilloConfig.cmake" @ONLY) + +message(STATUS "Generating '${PROJECT_BINARY_DIR}/ArmadilloConfigVersion.cmake'") +configure_file(build_aux/cmake/InstallFiles/ArmadilloConfigVersion.cmake.in + "${PROJECT_BINARY_DIR}/ArmadilloConfigVersion.cmake" @ONLY) + + +# Install the export set for use with the install-tree +install(EXPORT ArmadilloLibraryDepends DESTINATION + "${INSTALL_DATA_DIR}/Armadillo/CMake" + COMPONENT dev) + + +## GLOBAL INSTALL FILES +# Create ArmadilloConfig.cmake file for the use from the install tree +# and install it +set(ARMADILLO_INCLUDE_DIRS "${INSTALL_INCLUDE_DIR}") +set(ARMADILLO_LIB_DIR "${INSTALL_LIB_DIR}") +set(ARMADILLO_CMAKE_DIR "${INSTALL_DATA_DIR}/Armadillo/CMake") + + +message(STATUS "Generating '${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfig.cmake'") +# copy/change config and configVersion file (modify only the @xyz@ variables) +configure_file(build_aux/cmake/InstallFiles/ArmadilloConfig.cmake.in + "${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfig.cmake" @ONLY) + +message(STATUS "Generating '${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfigVersion.cmake'") +configure_file(build_aux/cmake/InstallFiles/ArmadilloConfigVersion.cmake.in + "${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfigVersion.cmake" @ONLY) + +# Install files to be found by cmake users with find_package() +install(FILES + "${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfig.cmake" + "${PROJECT_BINARY_DIR}/InstallFiles/ArmadilloConfigVersion.cmake" + DESTINATION "${ARMADILLO_CMAKE_DIR}" COMPONENT dev) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/LICENSE.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/LICENSE.txt Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,16 @@ +The Armadillo C++ library is provided without any warranty +of fitness for any purpose. You can redistribute the library +and/or modify it under the terms of the GNU Lesser General +Public License (LGPL) as published by the Free Software +Foundation, either version 3 of the License or (at your option) +any later version. + +Note that the LGPL v3 is formulated as an extension/modification +of the GPL v3 license, providing additional permissions. +For example, programs that use Armadillo can be distributed under +a different license, provided some conditions are met. + +A copy of the LGPL and GPL licenses is provided in the +"licenses/LGPL.txt" and "licenses/GPL.txt" files, respectively. + +More info: http://www.opensource.org/licenses diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/README.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/README.txt Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,455 @@ +=== Contents === + +1: Introduction + 1.1: Citation Details + +2: Installation + 2.0: Preliminaries + 2.1: Manual Installation + 2.2: Installation on Linux / Mac OS X + 2.3: Installation on MS Windows + +3: Compiling Programs and Linking + 3.0: Examples + 3.1: Compiling & Linking on Linux / Mac OS X + 3.2: Compiling & Linking on MS Windows + +4: Caveats + 4.0: Support for ATLAS + 4.1: Support for ACML and Intel MKL + +5: Documentation / Reference Manual + +6: FAQs and Bug Reports + +7: Credits + +8: License + + + + +=== 1.0: Introduction === + +Armadillo is a C++ linear algebra library (matrix maths) +aiming towards a good balance between speed and ease of use. +Integer, floating point and complex numbers are supported, +as well as a subset of trigonometric and statistics functions. +Various matrix decompositions are provided through optional +integration with LAPACK or high-performance LAPACK-compatible +libraries. + +A delayed evaluation approach is employed (during compile time) +to combine several operations into one and reduce (or eliminate) +the need for temporaries. This is accomplished through recursive +templates and template meta-programming. + +This library is useful if C++ has been decided as the language +of choice (due to speed and/or integration capabilities), +rather than another language like Matlab or Octave. +It is distributed under a license that is useful in both +open-source and proprietary contexts. + +Armadillo is primarily developed at NICTA (Australia), +with contributions from around the world. +More information about NICTA can be obtained from: + http://nicta.com.au + + + +=== 1.1: Citation Details === + +If you use Armadillo in your research and/or software, +we would appreciate a citation to the following tech report: + + Conrad Sanderson. + Armadillo: An Open Source C++ Linear Algebra Library for + Fast Prototyping and Computationally Intensive Experiments. + Technical Report, NICTA, 2010. + + + +=== 2.0: Installation: Preliminaries === + +Armadillo makes extensive use of template meta-programming, +recursive templates and template based function overloading. +As such, C++ compilers which do not fully implement the C++ +standard may not work correctly. + +The functionality of Armadillo is partly dependent on other +libraries -- mainly LAPACK and BLAS. Armadillo can work without +LAPACK or BLAS, but its functionality will be reduced. +In particular, basic functionality will be available +(eg. matrix addition and multiplication), but things like +eigen decomposition or will not be. Matrix multiplication +(mainly for big matrices) may not be as fast. + +For manual installation on all systems, see section 2.1. + +For installation on Linux / Mac OS X systems, see section 2.2. +The Linux installation is also likely to work on other Unix-like +systems, such as FreeBSD, NetBSD, OpenBSD, Solaris, CygWin, etc. + +For installation on MS Windows, see section 2.3. + + + +=== 2.1: Manual Installation === + +The manual installation is comprised of 3 steps: + +* Step 1: + Copy the entire "include" folder to a convenient location + and tell your compiler to use that location for header files + (in addition to the locations it uses already). + Alternatively, you can use the "include" folder directly. + +* Step 2: + Modify "include/armadillo_bits/config.hpp" to indicate + which libraries are currently available on your system. + For example, if you have LAPACK and BLAS present, + uncomment the following lines: + + #define ARMA_USE_LAPACK + #define ARMA_USE_BLAS + +* Step 3: + If you have LAPACK and/or BLAS present, configure your + compiler to link with these libraries. + + You can also link with the the equivalent of LAPACK and BLAS, + eg. Intel's MKL or AMD's ACML. Under Mac OS X, link using + -framework Accelerate + + + +=== 2.2: Installation on Linux / Mac OS X === + +If you have installed Armadillo using an RPM or DEB package, +you don't need to do anything else. Otherwise read on. + +You can use the manual installation process as described in +section 2.1, or the following CMake based automatic installation. + +* Step 1: + If CMake is not already be present on your system, download + it from http://www.cmake.org + + On major Linux systems (such as Fedora, Ubuntu, Debian, etc), + cmake is available as a pre-built package, though it may need + to be explicitly installed (using a tool such as PackageKit, + yum, rpm, apt, aptitude, etc). + +* Step 2: + If you have BLAS and/or LAPACK, install them before installing + Armadillo. Under Mac OS X this is not necessary. + + On Linux systems it is recommended that the following libraries + are present: LAPACK, BLAS, ATLAS and Boost. LAPACK and BLAS are + the most important. If you have ATLAS and Boost, it's also necessary + to have the corresponding header files installed. + +* Step 3: + Open a shell (command line), change into the directory that was + created by unpacking the armadillo archive, and type the following + commands: + + cmake . + make + + The full stop separated from "cmake" by a space is important. + CMake will figure out what other libraries are currently installed + and will modify Armadillo's configuration correspondingly. + CMake will also generate a run-time armadillo library, which is a + combined alias for all the relevant libraries present on your system + (eg. BLAS, LAPACK and ATLAS). + + If you need to re-run cmake, it's a good idea to first delete the + "CMakeCache.txt" file (not "CMakeLists.txt"). + +* Step 4: + If you have access to root/administrator/superuser privileges, + first enable the privileges (eg. through "su" or "sudo") + and then type the following command: + + make install + + If you don't have root/administrator/superuser privileges, + type the following command: + + make install DESTDIR=my_usr_dir + + where "my_usr_dir" is for storing C++ headers and library files. + Make sure your C++ compiler is configured to use the sub-directories + present within this directory. + + + +=== 2.3: Installation on MS Windows === + +There is currently no automatic installation for Windows. +Please use the manual installation process described in section 2.1. + +Pre-compiled 32 bit versions of BLAS and LAPACK libraries +for Windows are provided in the "examples/libs_win32" folder. +If the provided libraries don't work for you, see section 3.2. + + + +=== 3.0: Compiling Programs and Linking: Examples === + +The "examples" directory contains several quick example programs +that use the Armadillo library. If Armadillo was installed manually +(ie. according to section 2.1), you will also need to explicitly +link your programs with the libraries that were specified in +"include/armadillo_bits/config.hpp". + +"example1.cpp" may require the BLAS library or its equivalent. +"example2.cpp" requires the LAPACK library or its equivalent +(eg. the Accelerate framework on Mac OS X). + +You may get errors at compile or run time if BLAS and/or LAPACK +functions are not available. + +NOTE: As Armadillo is a template library, we recommended that + optimisation is enabled during compilation. For example, + for the GCC compiler use -O1 or -O2 + + + +=== 3.1: Compiling & Linking on Linux / Mac OS X === + +Please see "examples/Makefile", which may may need to be configured +for your system. If Armadillo header files were installed in a +non-standard location, you will need to modify "examples/Makefile" +to tell the compiler where they are. + +In general, programs which use Armadillo are compiled along these lines: + g++ example1.cpp -o example1 -O1 -larmadillo + +(you may also need to specify the include directory via the -I switch) + +If you get linking errors, or if Armadillo was installed manually +and you specified that LAPACK and BLAS are available, you will +need to explicitly link with LAPACK and BLAS (or their equivalents), +for example: + g++ example1.cpp -o example1 -O1 -llapack -lblas + +(you may also need to specify the library directory via the -L switch) + +Notes: + + * under most Linux systems, using "-llapack -lblas" should be enough; + however, on Ubuntu and Debian you may need to add "-lgfortran" + + * under Mac OS X, try "-framework Accelerate" or "-llapack -lblas" + (the Accelerate option is usually the fastest) + + * under the Sun Studio compiler, try "-library=sunperf" + + + +=== 3.2: Compiling & Linking on MS Windows === + +As a courtesy, we've provided pre-compiled 32 bit versions of +LAPACK and BLAS for Windows, as well as MSVC project files to +compile example1.cpp and example2.cpp. +The project files are stored in the following folders: + examples/example1_win32 + examples/example2_win32 + +The LAPACK and BLAS libraries are stored in: + examples/lib_win32 + +Note that on 64 bit systems (such as Windows 7), dedicated +64 bit versions of BLAS and LAPACK are considerably faster. + +If you're not using MSVC, or you're getting "use of LAPACK needs +to be enabled" messages, you will need to manually modify +"include/armadillo_bits/config.hpp" to enable the use of +LAPACK and BLAS. Please see section 2.1 for more information. + +The MSCV project files were tested on 32 bit Windows XP with +Visual C++ 2008 (Express Edition). You may need to make adaptations +for 64 bit systems, later versions of Windows and/or the compiler. +For example, you may have to enable or disable the ARMA_BLAS_LONG +and ARMA_BLAS_UNDERSCORE macros in "armadillo_bits/config.hpp". + +To preserve our sanity, we (Armadillo developers) don't use Windows +on a regular basis, and as such can't help you with the adaptations. +For best results we recommend using an operating system that's +more reliable and more suitable for heavy duty work, +such as Linux or Mac OS X. + +The pre-compiled versions of LAPACK and BLAS were downloaded from: + http://www.fi.muni.cz/~xsvobod2/misc/lapack/ + +If the provided libraries don't work for you, try these versions: + http://www.stanford.edu/~vkl/code/libs.html + http://icl.cs.utk.edu/lapack-for-windows/lapack/ + http://software.intel.com/en-us/intel-mkl/ + http://www.amd.com/acml + +(the MKL and ACML libraries are generally the fastest) + + +If you want to compile BLAS and LAPACK yourself, you can find +the original sources at: + http://www.netlib.org/blas/ + http://www.netlib.org/lapack/ + +If you encounter issues with the MS Visual C++ compiler, +the following high-quality compilers are useful alternatives: + + * GCC (part MinGW) + http://www.mingw.org/ + + * GCC (part of CygWin) + http://www.cygwin.com/ + + * Intel's C++ compiler + http://software.intel.com/en-us/intel-compilers/ + +If using GCC, you'll need version 4.0 or better. +If using Intel's C++ compiler, you'll need version 10.0 or better. + + + +=== 4.0: Caveats: Support for ATLAS === + +Armadillo can use the ATLAS library for faster versions of +certain LAPACK and BLAS functions. Not all ATLAS functions are +currently used, and as such LAPACK should still be installed. + +The minimum recommended version of ATLAS is 3.8. +Old versions (eg. 3.6) can produce incorrect results +as well as corrupting memory, leading to random crashes. + +Users of Ubuntu and Debian based systems should explicitly +check that version 3.6 is not installed. It's better to +remove the old version and use the standard LAPACK library. + + + +=== 4.1: Caveats: Support for ACML and Intel MKL === + +Armadillo can work with AMD Core Math Library and Intel's +Math Kernel Library (MKL), however there are several caveats. + +On Linux systems, ACML and MKL are typically installed in a +non-standard location, which can cause problems during linking. + +Before installing Armadillo, the system should know where the ACML or MKL +libraries are located (eg., "/opt/intel/mkl/10.2.2.025/lib/em64t/"). +This can be achieved by setting the LD_LIBRARY_PATH environment variable, +or, for a more permanent solution, adding the location of the libraries +to "/etc/ld.so.conf". It may also be possible to store a text file +with the location in the "/etc/ld.so.conf.d" directory. +In the latter two cases you will need to run "ldconfig" afterwards. + +The default installations of ACML 4.4.0 and MKL 10.2.2.025 are known +to have issues with SELinux, which is turned on by default in Fedora +(and possibly RHEL). The problem may manifest itself during run-time, +where the run-time linker reports permission problems. +It is possible to work around the problem by applying an appropriate +SELinux type to all ACML and MKL libraries. + +If you have ACML or MKL installed and they are persistently giving +you problems during linking, you can disable the support for them +by editing the "CMakeLists.txt" file, deleting "CMakeCache.txt" and +re-running the CMake based installation. Specifically, comment out +the lines containing: + INCLUDE(ARMA_FindMKL) + INCLUDE(ARMA_FindACMLMP) + INCLUDE(ARMA_FindACML) + + + +=== 5: Documentation / Reference Manual === + +A reference manual (user documentation) is available at +http://arma.sourceforge.net or in the "docs" directory. +Use a web browser to open the "docs/index.html" file. + +The user documentation explains how to use Armadillo's +classes and functions, with snippets of example code. + + + +=== 6: FAQs and Bug Reports === + +Answers to Frequently Asked Questions (FAQs) can be found at: + http://arma.sourceforge.net/faq.html + +This library has gone through extensive testing and +has been successfully used in production environments. +However, as with almost all software, it's impossible +to guarantee 100% correct functionality. + +If you find a bug in the library (or the documentation), +we are interested in hearing about it. Please make a small +self-contained program which exposes the bug and send the +program source (as well as the bug description) to the +developers. The developers' contact details are available at: + http://arma.sourceforge.net/contact.html + + + +=== 7: Credits === + +Main sponsoring organisation: +- NICTA + http://nicta.com.au + +Main developers: +- Conrad Sanderson - http://itee.uq.edu.au/~conrad/ +- Ian Cullinan +- Dimitrios Bouzas +- Stanislav Funiak + +Contributors: +- Eric R. Anderson +- Benoît Bayol +- Salim Bcoin +- Justin Bedo +- Darius Braziunas +- Ted Campbell +- Clement Creusot +- Ryan Curtin +- Chris Davey +- Dirk Eddelbuettel +- Romain Francois +- Piotr Gawron +- Charles Gretton +- Benjamin Herzog +- Edmund Highcock +- Kshitij Kulshreshtha +- Oka Kurniawan +- Simen Kvaal +- David Lawrence +- Carlos Mendes +- Artem Novikov +- Martin Orlob +- Ken Panici +- Adam Piątyszek +- Jayden Platell +- Vikas Reddy +- Ola Rinta-Koski +- James Sanders +- Alexander Scherbatey +- Gerhard Schreiber +- Shane Stainsby +- Petter Strandmark +- Paul Torfs +- Simon Urbanek +- Arnold Wiliem +- Yong Kang Wong + + + +=== 8: License === + +Please see the "LICENSE.txt" file. + + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/InstallFiles/ArmadilloConfig.cmake.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/InstallFiles/ArmadilloConfig.cmake.in Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,16 @@ +# - Config file for the Armadillo package +# It defines the following variables +# ARMADILLO_INCLUDE_DIRS - include directories for Armadillo +# ARMADILLO_LIBRARY_DIRS - library directories for Armadillo (normally not used!) +# ARMADILLO_LIBRARIES - libraries to link against + +# Tell the user project where to find our headers and libraries +set(ARMADILLO_INCLUDE_DIRS "@ARMADILLO_INCLUDE_DIRS@") +set(ARMADILLO_LIBRARY_DIRS "@ARMADILLO_LIB_DIR@") + +# Our library dependencies (contains definitions for IMPORTED targets) +include("@ARMADILLO_CMAKE_DIR@/ArmadilloLibraryDepends.cmake") + +# These are IMPORTED targets created by ArmadilloLibraryDepends.cmake +set(ARMADILLO_LIBRARIES armadillo) + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/InstallFiles/ArmadilloConfigVersion.cmake.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/InstallFiles/ArmadilloConfigVersion.cmake.in Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,11 @@ +set(PACKAGE_VERSION "@ARMADILLO_VERSION@") + +# Check whether the requested PACKAGE_FIND_VERSION is compatible +if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_EXACT TRUE) + endif() +endif() diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_CheckMathProto.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_CheckMathProto.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +# - Check if the prototype for a single argument math function exists. +# ARMA_CHECK_MATH_PROTO (FUNCTION NAMESPACE HEADER VARIABLE) +# +# FUNCTION - the name of the single argument math function you are looking for +# NAMESPACE - the name of the namespace +# HEADER - the header(s) where the prototype should be declared +# VARIABLE - variable to store the result +# +# The following variables may be set before calling this macro to +# modify the way the check is run: +# +# CMAKE_REQUIRED_FLAGS = string of compile command line flags +# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) +# CMAKE_REQUIRED_INCLUDES = list of include directories + +# adapted from "CheckPrototypeExists.cmake" +# ( http://websvn.kde.org/trunk/KDE/kdelibs/cmake/modules/CheckPrototypeExists.cmake ) +# on 2009-06-19 by Conrad Sanderson (conradsand at ieee dot org) + +# original copyright for "CheckPrototypeExists.cmake": +# +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +INCLUDE(CheckCXXSourceCompiles) + +MACRO (ARMA_CHECK_MATH_PROTO _SYMBOL _NAMESPACE _HEADER _RESULT) + + SET(_INCLUDE_FILES) + + FOREACH (it ${_HEADER}) + SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") + ENDFOREACH (it) + + SET(_TMP_SOURCE_CODE " +${_INCLUDE_FILES} +int main() + { + #if !defined(${_SYMBOL}) + int i = (${_NAMESPACE}::${_SYMBOL})(1.0); + #endif + return 0; + } +") + + CHECK_CXX_SOURCE_COMPILES("${_TMP_SOURCE_CODE}" ${_RESULT}) + +ENDMACRO (ARMA_CHECK_MATH_PROTO _SYMBOL _NAMESPACE _HEADER _RESULT) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_CheckProto.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_CheckProto.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,53 @@ +# - Check if the prototype for a non-overloaded function exists in a specified namespace. +# ARMA_CHECK_PROTO (FUNCTION NAMESPACE HEADER VARIABLE) +# +# FUNCTION - the name of the function you are looking for +# NAMESPACE - the name of the namespace +# HEADER - the header(s) where the prototype should be declared +# VARIABLE - variable to store the result +# +# The following variables may be set before calling this macro to +# modify the way the check is run: +# +# CMAKE_REQUIRED_FLAGS = string of compile command line flags +# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) +# CMAKE_REQUIRED_INCLUDES = list of include directories + +# adapted from "CheckPrototypeExists.cmake" +# ( http://websvn.kde.org/trunk/KDE/kdelibs/cmake/modules/CheckPrototypeExists.cmake ) +# on 2009-06-19 by Conrad Sanderson (conradsand at ieee dot org) + +# original copyright for "CheckPrototypeExists.cmake": +# +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +INCLUDE(CheckCXXSourceCompiles) + +MACRO (ARMA_CHECK_PROTO _SYMBOL _NAMESPACE _HEADER _RESULT) + + SET(_INCLUDE_FILES) + + FOREACH (it ${_HEADER}) + SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") + ENDFOREACH (it) + + SET(_TMP_SOURCE_CODE " +${_INCLUDE_FILES} +int +main() + { + #if !defined(${_SYMBOL}) + int i = sizeof(&(${_NAMESPACE}::${_SYMBOL})); + #endif + return 0; + } +") + + CHECK_CXX_SOURCE_COMPILES("${_TMP_SOURCE_CODE}" ${_RESULT}) + +ENDMACRO (ARMA_CHECK_PROTO _SYMBOL _NAMESPACE _HEADER _RESULT) + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindACML.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindACML.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +# - Find AMD's ACML library (no includes) which provides optimised BLAS and LAPACK functions +# This module defines +# ACML_LIBRARIES, the libraries needed to use ACML. +# ACML_FOUND, If false, do not try to use ACML. +# also defined, but not for general use are +# ACML_LIBRARY, where to find the ACML library. + +SET(ACML_NAMES ${ACML_NAMES} acml) +FIND_LIBRARY(ACML_LIBRARY + NAMES ${ACML_NAMES} + PATHS /usr/lib64 /usr/lib /usr/*/lib64 /usr/*/lib /usr/*/gfortran64/lib/ /usr/*/gfortran32/lib/ /usr/local/lib64 /usr/local/lib /opt/lib64 /opt/lib /opt/*/lib64 /opt/*/lib /opt/*/gfortran64/lib/ /opt/*/gfortran32/lib/ + ) + +IF (ACML_LIBRARY) + SET(ACML_LIBRARIES ${ACML_LIBRARY}) + SET(ACML_FOUND "YES") +ELSE (ACML_LIBRARY) + SET(ACML_FOUND "NO") +ENDIF (ACML_LIBRARY) + + +IF (ACML_FOUND) + IF (NOT ACML_FIND_QUIETLY) + MESSAGE(STATUS "Found the ACML library: ${ACML_LIBRARIES}") + ENDIF (NOT ACML_FIND_QUIETLY) +ELSE (ACML_FOUND) + IF (ACML_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find the ACML library") + ENDIF (ACML_FIND_REQUIRED) +ENDIF (ACML_FOUND) + +# Deprecated declarations. +GET_FILENAME_COMPONENT (NATIVE_ACML_LIB_PATH ${ACML_LIBRARY} PATH) + +MARK_AS_ADVANCED( + ACML_LIBRARY + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindACMLMP.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindACMLMP.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +# - Find AMD's ACMLMP library (no includes) which provides optimised and parallelised BLAS and LAPACK functions +# This module defines +# ACMLMP_LIBRARIES, the libraries needed to use ACMLMP. +# ACMLMP_FOUND, If false, do not try to use ACMLMP. +# also defined, but not for general use are +# ACMLMP_LIBRARY, where to find the ACMLMP library. + +SET(ACMLMP_NAMES ${ACMLMP_NAMES} acml_mp) +FIND_LIBRARY(ACMLMP_LIBRARY + NAMES ${ACMLMP_NAMES} + PATHS /usr/lib64 /usr/lib /usr/*/lib64 /usr/*/lib /usr/*/gfortran64_mp/lib/ /usr/*/gfortran32_mp/lib/ /usr/local/lib64 /usr/local/lib /opt/lib64 /opt/lib /opt/*/lib64 /opt/*/lib /opt/*/gfortran64_mp/lib/ /opt/*/gfortran32_mp/lib/ + ) + +IF (ACMLMP_LIBRARY) + SET(ACMLMP_LIBRARIES ${ACMLMP_LIBRARY}) + SET(ACMLMP_FOUND "YES") +ELSE (ACMLMP_LIBRARY) + SET(ACMLMP_FOUND "NO") +ENDIF (ACMLMP_LIBRARY) + + +IF (ACMLMP_FOUND) + IF (NOT ACMLMP_FIND_QUIETLY) + MESSAGE(STATUS "Found the ACMLMP library: ${ACMLMP_LIBRARIES}") + ENDIF (NOT ACMLMP_FIND_QUIETLY) +ELSE (ACMLMP_FOUND) + IF (ACMLMP_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find the ACMLMP library") + ENDIF (ACMLMP_FIND_REQUIRED) +ENDIF (ACMLMP_FOUND) + +# Deprecated declarations. +GET_FILENAME_COMPONENT (NATIVE_ACMLMP_LIB_PATH ${ACMLMP_LIBRARY} PATH) + +MARK_AS_ADVANCED( + ACMLMP_LIBRARY + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindBLAS.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindBLAS.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +# - Find a BLAS library (no includes) +# This module defines +# BLAS_LIBRARIES, the libraries needed to use BLAS. +# BLAS_FOUND, If false, do not try to use BLAS. +# also defined, but not for general use are +# BLAS_LIBRARY, where to find the BLAS library. + +SET(BLAS_NAMES ${BLAS_NAMES} blas) +FIND_LIBRARY(BLAS_LIBRARY + NAMES ${BLAS_NAMES} + PATHS /usr/lib64/atlas /usr/lib/atlas /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib + ) + +IF (BLAS_LIBRARY) + SET(BLAS_LIBRARIES ${BLAS_LIBRARY}) + SET(BLAS_FOUND "YES") +ELSE (BLAS_LIBRARY) + SET(BLAS_FOUND "NO") +ENDIF (BLAS_LIBRARY) + + +IF (BLAS_FOUND) + IF (NOT BLAS_FIND_QUIETLY) + MESSAGE(STATUS "Found a BLAS library: ${BLAS_LIBRARIES}") + ENDIF (NOT BLAS_FIND_QUIETLY) +ELSE (BLAS_FOUND) + IF (BLAS_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find a BLAS library") + ENDIF (BLAS_FIND_REQUIRED) +ENDIF (BLAS_FOUND) + +# Deprecated declarations. +GET_FILENAME_COMPONENT (NATIVE_BLAS_LIB_PATH ${BLAS_LIBRARY} PATH) + +MARK_AS_ADVANCED( + BLAS_LIBRARY + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindCBLAS.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindCBLAS.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,47 @@ +# - Find CBLAS (includes and library) +# This module defines +# CBLAS_INCLUDE_DIR +# CBLAS_LIBRARIES +# CBLAS_FOUND +# also defined, but not for general use are +# CBLAS_LIBRARY, where to find the library. + +FIND_PATH(CBLAS_INCLUDE_DIR cblas.h +/usr/include/atlas/ +/usr/local/include/atlas/ +/usr/include/ +/usr/local/include/ +) + +SET(CBLAS_NAMES ${CBLAS_NAMES} cblas) +FIND_LIBRARY(CBLAS_LIBRARY + NAMES ${CBLAS_NAMES} + PATHS /usr/lib64/atlas /usr/lib/atlas /usr/local/lib64/atlas /usr/local/lib/atlas /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib + ) + +IF (CBLAS_LIBRARY AND CBLAS_INCLUDE_DIR) + SET(CBLAS_LIBRARIES ${CBLAS_LIBRARY}) + SET(CBLAS_FOUND "YES") +ELSE (CBLAS_LIBRARY AND CBLAS_INCLUDE_DIR) + SET(CBLAS_FOUND "NO") +ENDIF (CBLAS_LIBRARY AND CBLAS_INCLUDE_DIR) + + +IF (CBLAS_FOUND) + IF (NOT CBLAS_FIND_QUIETLY) + MESSAGE(STATUS "Found a CBLAS library: ${CBLAS_LIBRARIES}") + ENDIF (NOT CBLAS_FIND_QUIETLY) +ELSE (CBLAS_FOUND) + IF (CBLAS_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find a CBLAS library") + ENDIF (CBLAS_FIND_REQUIRED) +ENDIF (CBLAS_FOUND) + +# Deprecated declarations. +SET (NATIVE_CBLAS_INCLUDE_PATH ${CBLAS_INCLUDE_DIR} ) +GET_FILENAME_COMPONENT (NATIVE_CBLAS_LIB_PATH ${CBLAS_LIBRARY} PATH) + +MARK_AS_ADVANCED( + CBLAS_LIBRARY + CBLAS_INCLUDE_DIR + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindCLAPACK.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindCLAPACK.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,48 @@ +# - Find a version of CLAPACK (includes and library) +# This module defines +# CLAPACK_INCLUDE_DIR +# CLAPACK_LIBRARIES +# CLAPACK_FOUND +# also defined, but not for general use are +# CLAPACK_LIBRARY, where to find the library. + +FIND_PATH(CLAPACK_INCLUDE_DIR clapack.h +/usr/include/atlas/ +/usr/local/include/atlas/ +/usr/include/ +/usr/local/include/ +) + +SET(CLAPACK_NAMES ${CLAPACK_NAMES} lapack_atlas) +SET(CLAPACK_NAMES ${CLAPACK_NAMES} clapack) +FIND_LIBRARY(CLAPACK_LIBRARY + NAMES ${CLAPACK_NAMES} + PATHS /usr/lib64/atlas /usr/lib/atlas /usr/local/lib64/atlas /usr/local/lib/atlas /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib + ) + +IF (CLAPACK_LIBRARY AND CLAPACK_INCLUDE_DIR) + SET(CLAPACK_LIBRARIES ${CLAPACK_LIBRARY}) + SET(CLAPACK_FOUND "YES") +ELSE (CLAPACK_LIBRARY AND CLAPACK_INCLUDE_DIR) + SET(CLAPACK_FOUND "NO") +ENDIF (CLAPACK_LIBRARY AND CLAPACK_INCLUDE_DIR) + + +IF (CLAPACK_FOUND) + IF (NOT CLAPACK_FIND_QUIETLY) + MESSAGE(STATUS "Found a CLAPACK library: ${CLAPACK_LIBRARIES}") + ENDIF (NOT CLAPACK_FIND_QUIETLY) +ELSE (CLAPACK_FOUND) + IF (CLAPACK_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find a CLAPACK library") + ENDIF (CLAPACK_FIND_REQUIRED) +ENDIF (CLAPACK_FOUND) + +# Deprecated declarations. +SET (NATIVE_CLAPACK_INCLUDE_PATH ${CLAPACK_INCLUDE_DIR} ) +GET_FILENAME_COMPONENT (NATIVE_CLAPACK_LIB_PATH ${CLAPACK_LIBRARY} PATH) + +MARK_AS_ADVANCED( + CLAPACK_LIBRARY + CLAPACK_INCLUDE_DIR + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindLAPACK.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindLAPACK.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +# - Find a LAPACK library (no includes) +# This module defines +# LAPACK_LIBRARIES, the libraries needed to use LAPACK. +# LAPACK_FOUND, If false, do not try to use LAPACK. +# also defined, but not for general use are +# LAPACK_LIBRARY, where to find the LAPACK library. + +SET(LAPACK_NAMES ${LAPACK_NAMES} lapack) +FIND_LIBRARY(LAPACK_LIBRARY + NAMES ${LAPACK_NAMES} + PATHS /usr/lib64/atlas /usr/lib/atlas /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib + ) + +IF (LAPACK_LIBRARY) + SET(LAPACK_LIBRARIES ${LAPACK_LIBRARY}) + SET(LAPACK_FOUND "YES") +ELSE (LAPACK_LIBRARY) + SET(LAPACK_FOUND "NO") +ENDIF (LAPACK_LIBRARY) + + +IF (LAPACK_FOUND) + IF (NOT LAPACK_FIND_QUIETLY) + MESSAGE(STATUS "Found a LAPACK library: ${LAPACK_LIBRARIES}") + ENDIF (NOT LAPACK_FIND_QUIETLY) +ELSE (LAPACK_FOUND) + IF (LAPACK_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find a LAPACK library") + ENDIF (LAPACK_FIND_REQUIRED) +ENDIF (LAPACK_FOUND) + +# Deprecated declarations. +GET_FILENAME_COMPONENT (NATIVE_LAPACK_LIB_PATH ${LAPACK_LIBRARY} PATH) + +MARK_AS_ADVANCED( + LAPACK_LIBRARY + ) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindMKL.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/cmake/Modules/ARMA_FindMKL.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,47 @@ +# - Find the MKL libraries (no includes) +# This module defines +# MKL_LIBRARIES, the libraries needed to use Intel's implementation of BLAS & LAPACK. +# MKL_FOUND, If false, do not try to use MKL. + +SET(MKL_NAMES ${MKL_NAMES} mkl_lapack) +SET(MKL_NAMES ${MKL_NAMES} mkl_intel_thread) +SET(MKL_NAMES ${MKL_NAMES} mkl_core) +SET(MKL_NAMES ${MKL_NAMES} guide) +SET(MKL_NAMES ${MKL_NAMES} mkl) + +IF(CMAKE_SIZEOF_VOID_P EQUAL 8) + SET(MKL_NAMES ${MKL_NAMES} mkl_intel_lp64) +ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8) + SET(MKL_NAMES ${MKL_NAMES} mkl_intel) +ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8) + +FOREACH (MKL_NAME ${MKL_NAMES}) + FIND_LIBRARY(${MKL_NAME}_LIBRARY + NAMES ${MKL_NAME} + PATHS /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib /opt/intel/mkl/lib/lib64 /opt/intel/mkl/lib/ia32 /opt/intel/mkl/lib /opt/intel/*/mkl/lib/intel64 /opt/intel/*/mkl/lib/ia32/ /opt/mkl/*/lib/em64t /opt/mkl/*/lib/32 /opt/intel/mkl/*/lib/em64t /opt/intel/mkl/*/lib/32 + ) + + SET(TMP_LIBRARY ${${MKL_NAME}_LIBRARY}) + + IF(TMP_LIBRARY) + SET(MKL_LIBRARIES ${MKL_LIBRARIES} ${TMP_LIBRARY}) + ENDIF(TMP_LIBRARY) +ENDFOREACH(MKL_NAME) + +IF (MKL_LIBRARIES) + SET(MKL_FOUND "YES") +ELSE (MKL_LIBRARIES) + SET(MKL_FOUND "NO") +ENDIF (MKL_LIBRARIES) + +IF (MKL_FOUND) + IF (NOT MKL_FIND_QUIETLY) + MESSAGE(STATUS "Found MKL libraries: ${MKL_LIBRARIES}") + ENDIF (NOT MKL_FIND_QUIETLY) +ELSE (MKL_FOUND) + IF (MKL_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Could not find MKL libraries") + ENDIF (MKL_FIND_REQUIRED) +ENDIF (MKL_FOUND) + +# MARK_AS_ADVANCED(MKL_LIBRARY) diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/doxygen/blank_footer.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/doxygen/blank_footer.html Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,2 @@ + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/doxygen/doxygen.config --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/doxygen/doxygen.config Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,298 @@ +# Doxyfile 1.5.8 + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +DOXYFILE_ENCODING = UTF-8 +PROJECT_NAME = "Armadillo Technical" +PROJECT_NUMBER = "" +OUTPUT_DIRECTORY = +CREATE_SUBDIRS = NO +OUTPUT_LANGUAGE = English +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ABBREVIATE_BRIEF = +ALWAYS_DETAILED_SEC = YES +INLINE_INHERITED_MEMB = NO +FULL_PATH_NAMES = NO +STRIP_FROM_PATH = +STRIP_FROM_INC_PATH = +SHORT_NAMES = YES +JAVADOC_AUTOBRIEF = NO +QT_AUTOBRIEF = NO +MULTILINE_CPP_IS_BRIEF = YES +INHERIT_DOCS = YES +SEPARATE_MEMBER_PAGES = NO +TAB_SIZE = 2 +ALIASES = +OPTIMIZE_OUTPUT_FOR_C = NO +OPTIMIZE_OUTPUT_JAVA = NO +OPTIMIZE_FOR_FORTRAN = NO +OPTIMIZE_OUTPUT_VHDL = NO +EXTENSION_MAPPING = +BUILTIN_STL_SUPPORT = YES +CPP_CLI_SUPPORT = NO +SIP_SUPPORT = NO +IDL_PROPERTY_SUPPORT = YES +DISTRIBUTE_GROUP_DOC = NO +SUBGROUPING = YES +TYPEDEF_HIDES_STRUCT = NO +SYMBOL_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +EXTRACT_ALL = YES +EXTRACT_PRIVATE = YES +EXTRACT_STATIC = YES +EXTRACT_LOCAL_CLASSES = YES +EXTRACT_LOCAL_METHODS = NO +EXTRACT_ANON_NSPACES = YES +HIDE_UNDOC_MEMBERS = NO +HIDE_UNDOC_CLASSES = NO +HIDE_FRIEND_COMPOUNDS = NO +HIDE_IN_BODY_DOCS = NO +INTERNAL_DOCS = NO +CASE_SENSE_NAMES = NO +HIDE_SCOPE_NAMES = NO +SHOW_INCLUDE_FILES = YES +INLINE_INFO = YES +SORT_MEMBER_DOCS = NO +SORT_BRIEF_DOCS = NO +SORT_GROUP_NAMES = NO +SORT_BY_SCOPE_NAME = NO +GENERATE_TODOLIST = YES +GENERATE_TESTLIST = YES +GENERATE_BUGLIST = YES +GENERATE_DEPRECATEDLIST= YES +ENABLED_SECTIONS = +MAX_INITIALIZER_LINES = 30 +SHOW_USED_FILES = NO +SHOW_DIRECTORIES = YES +SHOW_FILES = YES +SHOW_NAMESPACES = YES +FILE_VERSION_FILTER = +LAYOUT_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +QUIET = YES +WARNINGS = NO +WARN_IF_UNDOCUMENTED = YES +WARN_IF_DOC_ERROR = YES +WARN_NO_PARAMDOC = NO +WARN_FORMAT = "$file:$line: $text" +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +INPUT = build_aux/doxygen/ \ + include/ \ + include/armadillo_bits + +INPUT_ENCODING = UTF-8 + +FILE_PATTERNS = armadillo \ + armadillo_itpp \ + *.hpp \ + *.doxy + +RECURSIVE = NO +EXCLUDE = +EXCLUDE_SYMLINKS = NO +EXCLUDE_PATTERNS = +EXCLUDE_SYMBOLS = +EXAMPLE_PATH = +EXAMPLE_PATTERNS = +EXAMPLE_RECURSIVE = NO +IMAGE_PATH = +INPUT_FILTER = +FILTER_PATTERNS = +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +SOURCE_BROWSER = YES +INLINE_SOURCES = YES +STRIP_CODE_COMMENTS = NO +REFERENCED_BY_RELATION = YES +REFERENCES_RELATION = YES +REFERENCES_LINK_SOURCE = YES +USE_HTAGS = NO +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +ALPHABETICAL_INDEX = YES +COLS_IN_ALPHA_INDEX = 5 +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +GENERATE_HTML = YES +HTML_OUTPUT = docs_tech +HTML_FILE_EXTENSION = .html +HTML_HEADER = +HTML_FOOTER = build_aux/doxygen/blank_footer.html +HTML_STYLESHEET = +HTML_ALIGN_MEMBERS = YES +HTML_DYNAMIC_SECTIONS = NO +GENERATE_DOCSET = NO +DOCSET_FEEDNAME = "Doxygen generated docs" +DOCSET_BUNDLE_ID = org.doxygen.Project +GENERATE_HTMLHELP = NO +CHM_FILE = +HHC_LOCATION = +GENERATE_CHI = NO +CHM_INDEX_ENCODING = +BINARY_TOC = NO +TOC_EXPAND = NO +GENERATE_QHP = NO +QCH_FILE = +QHP_NAMESPACE = +QHP_VIRTUAL_FOLDER = doc +QHP_CUST_FILTER_NAME = +QHP_CUST_FILTER_ATTRS = +QHP_SECT_FILTER_ATTRS = +QHG_LOCATION = +DISABLE_INDEX = NO +ENUM_VALUES_PER_LINE = 4 +GENERATE_TREEVIEW = YES +TREEVIEW_WIDTH = 250 +FORMULA_FONTSIZE = 10 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +GENERATE_LATEX = NO +LATEX_OUTPUT = latex +LATEX_CMD_NAME = latex +MAKEINDEX_CMD_NAME = makeindex +COMPACT_LATEX = NO +PAPER_TYPE = a4wide +EXTRA_PACKAGES = +LATEX_HEADER = +PDF_HYPERLINKS = NO +USE_PDFLATEX = NO +LATEX_BATCHMODE = NO +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +GENERATE_RTF = NO +RTF_OUTPUT = rtf +COMPACT_RTF = NO +RTF_HYPERLINKS = NO +RTF_STYLESHEET_FILE = +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +GENERATE_MAN = NO +MAN_OUTPUT = man +MAN_EXTENSION = .3 +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +GENERATE_XML = NO +XML_OUTPUT = xml +XML_SCHEMA = +XML_DTD = +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +GENERATE_PERLMOD = NO +PERLMOD_LATEX = NO +PERLMOD_PRETTY = YES +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +ENABLE_PREPROCESSING = NO +MACRO_EXPANSION = YES +EXPAND_ONLY_PREDEF = YES +SEARCH_INCLUDES = YES +INCLUDE_PATH = +INCLUDE_FILE_PATTERNS = +PREDEFINED = +EXPAND_AS_DEFINED = +SKIP_FUNCTION_MACROS = NO + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +TAGFILES = +GENERATE_TAGFILE = +ALLEXTERNALS = NO +EXTERNAL_GROUPS = YES +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +CLASS_DIAGRAMS = YES +MSCGEN_PATH = +HIDE_UNDOC_RELATIONS = NO +HAVE_DOT = NO +DOT_FONTNAME = FreeSans +DOT_FONTSIZE = 10 +DOT_FONTPATH = +CLASS_GRAPH = YES +COLLABORATION_GRAPH = YES +GROUP_GRAPHS = YES +UML_LOOK = NO +TEMPLATE_RELATIONS = YES +INCLUDE_GRAPH = YES +INCLUDED_BY_GRAPH = YES +CALL_GRAPH = NO +CALLER_GRAPH = NO +GRAPHICAL_HIERARCHY = YES +DIRECTORY_GRAPH = YES +DOT_IMAGE_FORMAT = png +DOT_PATH = +DOTFILE_DIRS = +DOT_GRAPH_MAX_NODES = 50 +MAX_DOT_GRAPH_DEPTH = 0 +DOT_TRANSPARENT = YES +DOT_MULTI_TARGETS = NO +GENERATE_LEGEND = YES +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Options related to the search engine +#--------------------------------------------------------------------------- + +SEARCHENGINE = NO diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/doxygen/main.doxy --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/doxygen/main.doxy Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,16 @@ +/*! +\mainpage + +\htmlonly + +
+See the associated technical report for an overview of the internal architecture: +
+
    +Conrad Sanderson. +
    Armadillo: An Open Source C++ Linear Algebra Library for Fast Prototyping and Computationally Intensive Experiments. +
    Technical Report, NICTA, 2010. +
+ +\endhtmlonly +*/ diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/build_aux/rpm/armadillo.spec --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/build_aux/rpm/armadillo.spec Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,227 @@ +Name: armadillo +Version: 1.2.0 +Release: 1%{?dist} +Summary: Fast C++ matrix library with interfaces to LAPACK and ATLAS + +Group: Development/Libraries +License: LGPLv3+ +URL: http://arma.sourceforge.net/ +Source: http://sourceforge.net/projects/arma/files/%{name}-%{version}.tar.gz +BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) +BuildRequires: cmake, boost-devel, blas-devel, lapack-devel, atlas-devel + +%description +Armadillo is a C++ linear algebra library (matrix maths) +aiming towards a good balance between speed and ease of use. +Integer, floating point and complex numbers are supported, +as well as a subset of trigonometric and statistics functions. +Various matrix decompositions are provided through optional +integration with LAPACK and ATLAS libraries. +A delayed evaluation approach is employed (during compile time) +to combine several operations into one and reduce (or eliminate) +the need for temporaries. This is accomplished through recursive +templates and template meta-programming. +This library is useful if C++ has been decided as the language +of choice (due to speed and/or integration capabilities), rather +than another language like Matlab or Octave. + + +%package devel +Summary: Development headers and documentation for the Armadillo C++ library +Group: Development/Libraries +Requires: %{name} = %{version}-%{release} +Requires: boost-devel, blas-devel, lapack-devel, atlas-devel, libstdc++-devel + +# The header files of Armadillo include some Boost and ATLAS header files, +# delivered within the boost-devel and atlas-devel sub-packages, respectively. +# However, since there is no explicit dependency on Boost or ATLAS libraries +# (most of Boost is delivered as header files only), the RPM building process +# does not detect these dependencies. These dependencies must therefore be +# added manually. + +%description devel +This package contains files necessary for development using the +Armadillo C++ library. It contains header files, example programs, +and user documentation (reference guide). + + +%prep +%setup -q + +# convert DOS end-of-line to UNIX end-of-line + +for file in README.txt; do + sed 's/\r//' $file >$file.new && \ + touch -r $file $file.new && \ + mv $file.new $file +done + +%build +%{cmake} +%{__make} VERBOSE=1 %{?_smp_mflags} + + +%install +rm -rf $RPM_BUILD_ROOT +%{__make} install DESTDIR=$RPM_BUILD_ROOT +rm -rf $RPM_BUILD_ROOT/%{_docdir}/%{name}-%{version}/ +mkdir -p $RPM_BUILD_ROOT/%{_docdir}/%{name}-%{version}/ +rm -f examples/Makefile.cmake +rm -rf examples/example1_win32 +rm -rf examples/example2_win32 +rm -rf examples/lib_win32 +cp -r LICENSE.txt licenses README.txt index.html examples docs $RPM_BUILD_ROOT/%{_docdir}/%{name}-%{version}/ + +%clean +rm -rf $RPM_BUILD_ROOT + + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%defattr(-,root,root,-) +%{_libdir}/*.so.* +%dir %{_docdir}/%{name}-%{version}/ +%doc %{_docdir}/%{name}-%{version}/LICENSE.txt +%doc %{_docdir}/%{name}-%{version}/licenses/ + +%files devel +%defattr(-,root,root,-) +%{_libdir}/*.so +%{_includedir}/armadillo +%{_includedir}/armadillo_bits/ +%{_includedir}/armadillo_itpp +%doc %{_docdir}/%{name}-%{version}/README.txt +%doc %{_docdir}/%{name}-%{version}/index.html +%doc %{_docdir}/%{name}-%{version}/examples/ +%doc %{_docdir}/%{name}-%{version}/docs/ +%{_datadir}/Armadillo/ + +%changelog +* Mon Apr 18 2011 Conrad Sanderson - 1.2.0-1 +- spec updated for Armadillo 1.2.0 + +* Mon Nov 15 2010 Conrad Sanderson - 1.0.0-1 +- spec updated for Armadillo 1.0.0 + +* Thu Oct 14 2010 Conrad Sanderson - 0.9.90-1 +- spec updated for Armadillo 0.9.90 + +* Tue Sep 21 2010 Conrad Sanderson - 0.9.80-1 +- spec updated for Armadillo 0.9.80 + +* Wed Sep 01 2010 Conrad Sanderson - 0.9.70-1 +- spec updated for Armadillo 0.9.70 + +* Wed Aug 04 2010 Conrad Sanderson - 0.9.60-1 +- spec updated for Armadillo 0.9.60 + +* Wed Jul 14 2010 Conrad Sanderson - 0.9.52-1 +- spec updated for Armadillo 0.9.52 + +* Wed Jul 07 2010 Conrad Sanderson - 0.9.50-1 +- spec updated for Armadillo 0.9.50 + +* Wed Jun 02 2010 Conrad Sanderson - 0.9.10-1 +- spec updated for Armadillo 0.9.10 + +* Fri May 14 2010 Conrad Sanderson - 0.9.8-1 +- spec updated for Armadillo 0.9.8 + +* Tue Apr 28 2010 Conrad Sanderson - 0.9.6-1 +- spec updated for Armadillo 0.9.6 + +* Tue Mar 16 2010 Conrad Sanderson - 0.9.4-1 +- spec updated for Armadillo 0.9.4 + +* Tue Mar 02 2010 Conrad Sanderson - 0.9.2-2 +- added explicit dependencies to the devel package + +* Tue Mar 02 2010 Conrad Sanderson - 0.9.2-1 +- spec updated for Armadillo 0.9.2 + +* Fri Feb 05 2010 Conrad Sanderson - 0.9.0-1 +- spec updated for Armadillo 0.9.0 + +* Mon Jan 27 2010 Conrad Sanderson - 0.8.2-1 +- spec updated for Armadillo 0.8.2 + +* Mon Dec 14 2009 Conrad Sanderson - 0.8.0-1 +- spec updated for Armadillo 0.8.0 + +* Fri Oct 23 2009 Conrad Sanderson - 0.7.2-1 +- spec updated for Armadillo 0.7.2 + +* Mon Oct 05 2009 Conrad Sanderson - 0.7.0-1 +- spec updated for Armadillo 0.7.0 + +* Fri Jul 24 2009 Fedora Release Engineering - 0.6.12-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Wed Jul 06 2009 Conrad Sanderson - 0.6.12-2 +- added conversion of DOS end-of-line to UNIX end-of-line for README.txt + +* Wed Jun 22 2009 Conrad Sanderson - 0.6.12-1 +- spec updated for Armadillo 0.6.12 + +* Wed Jun 15 2009 Conrad Sanderson - 0.6.11-8 +- cleanup of dependencies +- explanation as to why boost-devel and atlas-devel are required by armadillo-devel + +* Wed Jun 09 2009 Conrad Sanderson - 0.6.11-7 +- explicit declaration of doc directory in the main package +- explicitly marked doc files in both packages + +* Wed Jun 09 2009 Conrad Sanderson - 0.6.11-6 +- removed symlinks +- placed all documentation and license files into one directory that is shared by both packages + +* Wed Jun 09 2009 Conrad Sanderson - 0.6.11-5 +- added symlinks to LICENSE.txt and licenses in the devel package + +* Wed Jun 08 2009 Conrad Sanderson - 0.6.11-4 +- added LICENSE.txt to the main package + +* Wed May 22 2009 Conrad Sanderson - 0.6.11-3 +- using cmake macro instead of directly calling cmake + +* Wed May 21 2009 Conrad Sanderson - 0.6.11-2 +- moved all text files to devel package to retain consistency with the layout in the original .tar.gz + +* Wed May 08 2009 Conrad Sanderson - 0.6.10-2 +- Removed several explicit build dependencies that are provided by default in Fedora +- Simplified handling of doc files + +* Wed May 02 2009 Conrad Sanderson - 0.6.10-1 +- Updated spec file for Armadillo 0.6.10 + +* Wed Apr 02 2009 Conrad Sanderson +- Updated list of files in 0.6.7 release + +* Wed Apr 02 2009 Conrad Sanderson +- Updated description + +* Wed Mar 24 2009 Conrad Sanderson +- Added explicit dependence on libstdc++-devel + +* Wed Mar 17 2009 Conrad Sanderson +- Simplified specification of directories +- Removed library packages specified by "Requires", as library dependencies are detected automatically + +* Wed Mar 12 2009 Conrad Sanderson +- Modified to generate separate devel package (subsumes previous doc package) +- Removed redundant packages specified by "BuildRequires" +- Added CMake installation prefixes to allow for x86_64 + +* Wed Feb 4 2009 Conrad Sanderson +- Modified to generate separate doc package + +* Thu Jan 28 2009 Conrad Sanderson +- Added argument to cmake: -DCMAKE_INSTALL_PREFIX=/usr + +* Thu Jan 22 2009 Conrad Sanderson +- Initial spec file prepared + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/configure --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/configure Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,23 @@ +#!/bin/sh + +ABORT=no + +check_cmake() + { + (cmake --version) /dev/null 2>&1 || + { + echo "error: cmake 2.6 must be present to configure and install Armadillo" + echo "" + echo "cmake might be available as a package for your system," + echo "or can be downloaded from http://cmake.org" + ABORT=yes + } + } + +check_cmake + +test "$ABORT" = yes && exit -1 + +rm -f CMakeCache.txt +cmake . + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/docs/armadillo_icon.png Binary file armadillo-2.4.4/docs/armadillo_icon.png has changed diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/docs/armadillo_nicta_2010.pdf Binary file armadillo-2.4.4/docs/armadillo_nicta_2010.pdf has changed diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/docs/index.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/docs/index.html Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,9667 @@ + + + + + Armadillo: C++ linear algebra library + + + + +
+ + + + + + +
+ + + + + + + + +
+ Reference for Armadillo 2.4.4 +
+ (Loco Lounge Lizard) + 		+ to Armadillo home page +
+ to NICTA home page +
+
+
+
+ +[top] + + + + + +Preamble +
+
+ + + + + + + + + +
+ + +  + +
+		 + +
+ +
+
+ +Matrix, Vector, Cube and Field Classes + +
+ +Member Functions & Variables + +
+ +Other Classes + +
+ +Generated Vectors/Matrices/Cubes + +
+ +Functions Individually Applied to Each Element of a Matrix/Cube + +
+ +Scalar Valued Functions of Vectors/Matrices/Cubes + +
+ +Scalar/Vector Valued Functions of Vectors/Matrices + +
+ +Vector/Matrix/Cube Valued Functions of Vectors/Matrices/Cubes + +
+ +Decompositions, Inverses and Equation Solvers + +
+ +Miscellaneous + +
+ +
+
+
+
+
+
+Matrix, Vector, Cube and Field Classes +
+
+
+
+ +Mat<type> +
mat +
cx_mat +
    +
  • +The root template matrix class is Mat<type>, where type can be one of: +char, int, float, double, std::complex<double>, etc. +
    • +
    +
  • +For convenience the following typedefs have been defined: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + umat + +  =  + + Mat<uword> +
      + imat + +  =  + + Mat<sword> +
      + fmat + +  =  + + Mat<float> +
      + mat + +  =  + + Mat<double> +
      + cx_fmat + +  =  + + Mat<cx_float> +
      + cx_mat + +  =  + + Mat<cx_double> +
      +
    +
    • +
    +
  • +In this documentation the mat type is used for convenience; +it is possible to use other types instead, eg. fmat +
    • +
    +
  • +Functions which are wrappers for LAPACK or ATLAS functions (generally matrix decompositions) are only valid for the following types: +fmat, mat, cx_fmat, cx_mat +
    • +
    +
  • +Elements are stored with column-major ordering (ie. column by column) +
    • +
    + +
  • +Constructors: +
      +
    • mat()
      • +
    • mat(n_rows, n_cols)
      • +
    • mat(mat)
      • +
    • mat(vec)
      • +
    • mat(rowvec)
      • +
    • mat(string)
      • +
    • mat(initialiser_list)   (C++11 only)
      • +
    • cx_mat(mat,mat)   (for constructing a complex matrix out of two real matrices)
      • +
    +
    • +
    +
  • +The string format for the constructor is elements separated by spaces, and rows denoted by semicolons. +For example, the 2x2 identity matrix can be created using the format string "1 0; 0 1". +While string based initialisation is compact, directly setting the elements or using element initialisation is considerably faster. +
    • +
    + +
  • +Advanced constructors: +
    +
    +
      +
    • mat(aux_mem*, n_rows, n_cols, copy_aux_mem = true, strict = true) +
      +
      +
        +Create a matrix using data from writeable auxiliary memory. +By default the matrix allocates its own memory and copies data from the auxiliary memory (for safety). +However, if copy_aux_mem is set to false, +the matrix will instead directly use the auxiliary memory (ie. no copying). +This is faster, but can be dangerous unless you know what you're doing! +
        +
        +The strict variable comes into effect only if copy_aux_mem is set to false +(ie. the matrix is directly using auxiliary memory). +If strict is set to true, +the matrix will be bound to the auxiliary memory for its lifetime; +the number of elements in the matrix can't be changed (directly or indirectly). +If strict is set to false, the matrix will not be bound to the auxiliary memory for its lifetime, +ie., the size of the matrix can be changed. +If the requested number of elements is different to the size of the auxiliary memory, +new memory will be allocated and the auxiliary memory will no longer be used. +
      +
      • +
      +
    • mat(const aux_mem*, n_rows, n_cols) +
      +
      +
        +Create a matrix by copying data from read-only auxiliary memory. +
      +
      • + +
      +
    • mat::fixed<n_rows, n_cols> +
      +
      +
        +Create a fixed size matrix, with the size specified via template arguments. +Memory for the matrix is allocated at compile time. +This is generally faster than dynamic memory allocation, but the size of the matrix can't be changed afterwards (directly or indirectly). +
        +
        +For convenience, there are several pre-defined typedefs for each matrix type +(where the types are: umat, imat, fmat, mat, cx_fmat, cx_mat). +The typedefs specify a square matrix size, ranging from 2x2 to 9x9. +The typedefs were defined by simply appending a two digit form of the size to the matrix type +-- for example, mat33 is equivalent to mat::fixed<3,3>, +while cx_mat44 is equivalent to cx_mat::fixed<4,4>. +
      +
      • +
      +
    • mat::fixed<n_rows, n_cols>(const aux_mem*) +
      +
      +
        +Create a fixed size matrix, with the size specified via template arguments, +and copying data from auxiliary memory. +
      +
      • +
    +
    • +
    +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+double x = A(1,2);
+
+mat B = A + A;
+mat C = A * B;
+mat D = A % B;
+
+cx_mat X(A,B);
+
+B.zeros();
+B.set_size(10,10);
+B.zeros(5,6);
+
+//
+// fixed size matrices:
+
+mat::fixed<5,6> F;
+F.ones();
+
+mat44 G;
+G.randn();
+
+cout << mat22().randu() << endl;
+
+//
+// constructing matrices from
+// auxiliary (external) memory:
+
+double aux_mem[24];
+mat H(aux_mem, 4, 6, false);
+
      +
    +
    • +
    +
  • Caveat: +For mathematical correctness, scalars are treated as 1x1 matrices during initialisation. +As such, the code below will not generate a 5x5 matrix with every element equal to 123.0: +
      +
      +mat A(5,5);
+A = 123.0;
+
      +
    +Use the following code instead: +
      +
      +mat A(5,5);
+A.fill(123.0);
+
      +
    +Or: +
      +
      +mat A = 123.0 * ones<mat>(5,5);
+
      +
    +
    +
  • +See also: + +
    • +
    +
+
+
+ +Col<type> +
colvec +
vec +
    +
  • +Classes for column vectors (matrices with one column) +
    • +
    +
  • The Col<type> class is derived from the Mat<type> class +and inherits most of the member functions +
    • +
    +
  • +For convenience the following typedefs have been defined: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + uvec, ucolvec + +  =  + + Col<uword> +
      + ivec, icolvec + +  =  + + Col<sword> +
      + fvec, fcolvec + +  =  + + Col<float> +
      + vec, colvec + +  =  + + Col<double> +
      + cx_fvec, cx_fcolvec + +  =  + + Col<cx_float> +
      + cx_vec, cx_colvec + +  =  + + Col<cx_double> +
      +
    +
    • +
    +
  • +In this documentation, the vec and colvec types have the same meaning and are used interchangeably +
    • +
    +
  • +In this documentation, the types vec or colvec are used for convenience; it is possible to use other types instead, eg. fvec, fcolvec +
    • +
    +
  • +Functions which take Mat as input can generally also take Col as input. +Main exceptions are functions which require square matrices +
    • +
    +
  • +Constructors +
      +
    • vec(n_elem=0)
      • +
    • vec(vec)
      • +
    • vec(mat)   (a std::logic_error exception is thrown if the given matrix has more than one column)
      • +
    • vec(string)   (elements separated by spaces)
      • +
    • vec(initialiser_list)   (C++11 only)
      • +
    +
    • +
    + +
  • +Advanced constructors: +
    +
    +
      +
    • vec(aux_mem*, number_of_elements, copy_aux_mem = true, strict = true) +
      +
      +
        +Create a column vector using data from writeable auxiliary memory. +By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). +However, if copy_aux_mem is set to false, +the vector will instead directly use the auxiliary memory (ie. no copying). +This is faster, but can be dangerous unless you know what you're doing! +
        +
        +The strict variable comes into effect only if copy_aux_mem is set to false +(ie. the vector is directly using auxiliary memory). +If strict is set to true, +the vector will be bound to the auxiliary memory for its lifetime; +the number of elements in the vector can't be changed (directly or indirectly). +If strict is set to false, the vector will not be bound to the auxiliary memory for its lifetime, +ie., the vector's size can be changed. +If the requested number of elements is different to the size of the auxiliary memory, +new memory will be allocated and the auxiliary memory will no longer be used. +
      +
      • +
      +
    • vec(const aux_mem*, number_of_elements) +
      +
      +
        +Create a column vector by copying data from read-only auxiliary memory. +
      +
      • +
      +
    • vec::fixed<number_of_elements> +
      +
      +
        +Create a fixed size column vector, with the size specified via the template argument. +Memory for the vector is allocated at compile time. +This is generally faster than dynamic memory allocation, but the size of the vector can't be changed afterwards (directly or indirectly). +
        +
        +For convenience, there are several pre-defined typedefs for each vector type +(where the types are: uvec, ivec, fvec, vec, cx_fvec, cx_vec as well as the corresponding colvec versions). +The pre-defined typedefs specify vector sizes ranging from 2 to 9. +The typedefs were defined by simply appending a single digit form of the size to the vector type +-- for example, vec3 is equivalent to vec::fixed<3>, +while cx_vec4 is equivalent to cx_vec::fixed<4>. +
      +
      • +
      +
    • vec::fixed<number_of_elements>(const aux_mem*) +
      +
      +
        +Create a fixed size column vector, with the size specified via the template argument, +and copying data from auxiliary memory. +
      +
      • +
    +
    • +
    +
    +
  • +Examples: +
      +
      +vec x(10);
+vec y = zeros<vec>(10,1);
+
+mat A = randu<mat>(10,10);
+vec z = A.col(5); // extract a column vector
+
      +
    +
    • +
    +
  • Caveat: +For mathematical correctness, scalars are treated as 1x1 matrices during initialisation. +As such, the code below will not generate a column vector with every element equal to 123.0: +
      +
      +vec q(5);
+q = 123.0;
+
      +
    +Use the following code instead: +
      +
      +vec q(5);
+q.fill(123.0);
+
      +
    +Or: +
      +
      +vec q = 123.0 * ones<vec>(5,1);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +Row<type> +
rowvec +
    +
  • +Classes for row vectors (matrices with one row) +
    • +
    +
  • The template Row<type> class is derived from the Mat<type> class +and inherits most of the member functions +
    • +
    +
  • +For convenience the following typedefs have been defined: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + urowvec + +  =  + + Row<uword> +
      + irowvec + +  =  + + Row<sword> +
      + frowvec + +  =  + + Row<float> +
      + rowvec + +  =  + + Row<double> +
      + cx_frowvec + +  =  + + Row<cx_float> +
      + cx_rowvec + +  =  + + Row<cx_double> +
      +
    +
    • +
    +
  • +In this documentation, the rowvec type is used for convenience; +it is possible to use other types instead, eg. frowvec +
    • +
    +
  • +Functions which take Mat as input can generally also take Row as input. +Main exceptions are functions which require square matrices +
    • +
    +
  • +Constructors +
      +
    • rowvec(n_elem=0)
      • +
    • rowvec(rowvec)
      • +
    • rowvec(mat)   (a std::logic_error exception is thrown if the given matrix has more than one row)
      • +
    • rowvec(string)   (elements separated by spaces)
      • +
    • rowvec(initialiser_list)   (C++11 only)
      • +
    +
    • +
    + +
  • +Advanced constructors: +
    +
    +
      +
    • rowvec(aux_mem*, number_of_elements, copy_aux_mem = true, strict = true) +
      +
      +
        +Create a row vector using data from writeable auxiliary memory. +By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). +However, if copy_aux_mem is set to false, +the vector will instead directly use the auxiliary memory (ie. no copying). +This is faster, but can be dangerous unless you know what you're doing! +
        +
        +The strict variable comes into effect only if copy_aux_mem is set to false +(ie. the vector is directly using auxiliary memory). +If strict is set to true, +the vector will be bound to the auxiliary memory for its lifetime; +the number of elements in the vector can't be changed (directly or indirectly). +If strict is set to false, the vector will not be bound to the auxiliary memory for its lifetime, +ie., the vector's size can be changed. +If the requested number of elements is different to the size of the auxiliary memory, +new memory will be allocated and the auxiliary memory will no longer be used. +
      +
      • +
      +
    • rowvec(const aux_mem*, number_of_elements) +
      +
      +
        +Create a row vector by copying data from read-only auxiliary memory. +
      +
      • +
      +
    • rowvec::fixed<number_of_elements> +
      +
      +
        +Create a fixed size row vector, with the size specified via the template argument. +Memory for the vector is allocated at compile time. +This is generally faster than dynamic memory allocation, but the size of the vector can't be changed afterwards (directly or indirectly). +
        +
        +For convenience, there are several pre-defined typedefs for each vector type +(where the types are: urowvec, irowvec, frowvec, rowvec, cx_frowvec, cx_rowvec). +The pre-defined typedefs specify vector sizes ranging from 2 to 9. +The typedefs were defined by simply appending a single digit form of the size to the vector type +-- for example, rowvec3 is equivalent to rowvec::fixed<3>, +while cx_rowvec4 is equivalent to cx_rowvec::fixed<4>. +
      +
      • +
      +
    • rowvec::fixed<number_of_elements>(const aux_mem*) +
      +
      +
        +Create a fixed size row vector, with the size specified via the template argument, +and copying data from auxiliary memory. +
      +
      • +
    +
    • +
    +
    +
  • +Examples: +
      +
      +rowvec x(10);
+rowvec y = zeros<mat>(1,10);
+
+mat A = randu<mat>(10,10);
+rowvec z = A.row(5); // extract a row vector
+
      +
    +
    • +
    +
  • +Caveat: +For mathematical correctness, scalars are treated as 1x1 matrices during initialisation. +As such, the code below will not generate a row vector with every element equal to 123.0: +
      +
      +rowvec r(5);
+r = 123.0;
+
      +
    +Use the following code instead: +
      +
      +rowvec r(5);
+r.fill(123.0);
+
      +
    +Or: +
      +
      +rowvec r = 123.0 * ones<rowvec>(1,5);
+
      +
    +
    +
  • See also: + +
    • +
    +
+
+
+ + +Cube<type> +
cube +
cx_cube +
    +
  • +Classes for cubes, also known as "3D matrices" +
    • +
    +
  • +The root template cube class is Cube<type>, where type can be one of: +char, int, float, double, std::complex<double>, etc +
    • +
    +
  • +For convenience the following typedefs have been defined: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + ucube + +  =  + + Cube<uword> +
      + icube + +  =  + + Cube<sword> +
      + fcube + +  =  + + Cube<float> +
      + cube + +  =  + + Cube<double> +
      + cx_fcube + +  =  + + Cube<cx_float> +
      + cx_cube + +  =  + + Cube<cx_double> +
      +
    +
    • +
    +
  • +In this documentation the cube type is used for convenience; +it is possible to use other types instead, eg. fcube +
    • +
    +
  • +Cube data is stored as a set of slices (matrices) stored contiguously within memory. +Within each slice, elements are stored with column-major ordering (ie. column by column) +
    • +
    +
  • +Each slice can be interpreted as a matrix, hence functions which take Mat as input can generally also take cube slices as input +
    • +
    + +
  • +Constructors: +
      +cube() +
      cube(cube) +
      cube(n_rows, n_cols, n_slices) +
      cx_cube(cube, cube) (for constructing a complex cube out of two real cubes) +
    +
    • +
    + + +
  • +Advanced constructors: +
    +
    +
      +
    • +cube::fixed<n_rows, n_cols, n_slices> +
      +
      +
        +Create a fixed size cube, with the size specified via template arguments. +Memory for the cube is allocated at compile time. +This is generally faster than dynamic memory allocation, but the size of the cube can't be changed afterwards (directly or indirectly). +
      +
      • +
      +
    • cube(aux_mem*, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = true) +
      +
      +
        +Create a cube using data from writeable auxiliary memory. +By default the cube allocates its own memory and copies data from the auxiliary memory (for safety). +However, if copy_aux_mem is set to false, +the cube will instead directly use the auxiliary memory (ie. no copying). +This is faster, but can be dangerous unless you know what you're doing! +
        +
        +The strict variable comes into effect only if copy_aux_mem is set to false +(ie. the cube is directly using auxiliary memory). +If strict is set to true, +the cube will be bound to the auxiliary memory for its lifetime; +the number of elements in the cube can't be changed (directly or indirectly). +If strict is set to false, the cube will not be bound to the auxiliary memory for its lifetime, +ie., the size of the cube can be changed. +If the requested number of elements is different to the size of the auxiliary memory, +new memory will be allocated and the auxiliary memory will no longer be used. +
      +
      • +
      +
    • cube(const aux_mem*, n_rows, n_cols, n_slices) +
      +
      +
        +Create a cube by copying data from read-only auxiliary memory. +
      +
      • +
    +
    • +
    +
    +
  • +Examples: +
      +
      +cube x(1,2,3);
+cube y = randu<cube>(4,5,6);
+
+mat A = y.slice(1);  // extract a slice from the cube
+                     // (each slice is a matrix)
+
+mat B = randu<mat>(4,5);
+y.slice(2) = B;     // set a slice in the cube
+
+cube q = y + y;     // cube addition
+cube r = y % y;     // element-wise cube multiplication
+
+cube::fixed<4,5,6> f;
+f.ones();
+
      +
    +
    • +
    +
  • +Caveats +
    +
    +
      +
    • +The size of individual slices can't be changed. +For example, the following will not work: +
        +
        +cube c(5,6,7);
+c.slice(0) = randu<mat>(10,20); // wrong size
+
        +
      +
      • +
    • +For mathematical correctness, scalars are treated as 1x1x1 cubes during initialisation. +As such, the code below will not generate a cube with every element equal to 123.0: +
        +
        +cube c(5,6,7);
+c = 123.0;
+
        +
      +Use the following code instead: +
        +
        +cube c(5,6,7);
+c.fill(123.0);
+
        +
      +Or: +
        +
        +cube c = 123.0 * ones<cube>(5,6,7);
+
        +
      +
      • +
    +
    +
  • +See also: + +
    • +
    +
+
+
+ + +field<object type> +
    +
  • +Class for one and two dimensional fields of arbitrary objects +
    • +
    +
  • +Constructors (where object type is another class, eg. std::string, mat, vec, rowvec, etc): +
      +field<object type>(n_elem=0) +
      field<object type>(n_rows, n_cols) +
      field<object type>(field<object type>) +
    +
    • +
    +
  • +Examples: +
      +
      +// create a field of strings
+field<std::string> S(3,2);
+
+S(0,0) = "hello";
+S(1,0) = "there";
+
+// string fields can be saved as plain text files
+S.save("string_field");
+
+// create a vec field with 3 rows and 2 columns
+field<vec> F(3,2);
+
+// access components of the field
+F(0,0) = vec(5);
+F(1,1) = randu<vec>(6);
+F(2,0).set_size(7);
+
+// access element 1 of the vec stored at 2,0
+double x = F(2,0)(1);
+
+// copy rows
+F.row(0) = F.row(2);
+
+// extract a row of vecs from F
+field<vec> G = F.row(1);
+
+// print the field to the standard output
+G.print("G =");
+
+// save the field to a binary file
+G.save("vec_field");
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+
+
+
+
+Member Functions & Variables +
+
+
+
+ + + +attributes +
    + + + + + + + + + + + + + + + + + + + + + + + +
    +.n_rows +   +(number of rows) +
    +.n_cols +   +(number of columns) +
    +.n_elem +   +(total number of elements) +
    +.n_slices +   +(number of slices) +
    +
+
+
    +
  • +Member variables which are read-only; +to change the size, use +.set_size(), +.copy_size(), +.zeros(), +.ones(), +or +.reset() +
    • +
    +
  • n_rows, n_cols and n_elem are applicable to Mat, Col, Row, Cube and field classes
    • +
    +
  • n_slices is applicable only to the Cube class
    • +
    +
  • +For the Col and Row classes, n_elem also indicates vector length
    • +
    +
  • The variables are of type uword
    • +
    +
  • +Examples: +
      +
      +mat X(4,5);
+cout << "X has " << X.n_cols << " columns" << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.colptr(col_number) +
    +
  • +Member function of Mat +
    • +
    +
  • +Obtain a raw pointer to the memory used by the specified column +
    • +
    +
  • +As soon as the size of the matrix is changed, the pointer is no longer valid +
    • +
    +
  • This function is not recommended for use unless you know what you're doing +-- you may wish to use submatrix views instead +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+double* mem = A.colptr(2);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.copy_size(A) +
    +
  • +Member function of Mat, Col, Row, Cube and field +
    • +
    +
  • +Set the size to be the same as object A +
    • +
    +
  • +Object A must be of the same root type as the object being modified +(eg. you can't set the size of a matrix by providing a cube) +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,6);
+mat B;
+B.copy_size(A);
+
+cout << B.n_rows << endl;
+cout << B.n_cols << endl;
+
      +
    +
    • +
+
+

+ + +.diag(k=0) +
    +
  • +Member function of Mat. +
    • +
    +
  • +Read/write access to the k-th diagonal in a matrix +
    • +
    +
  • The argument k is optional -- by default the main diagonal is accessed (k=0)
    • +
    +
  • For k > 0, the k-th super-diagonal is accessed (top-right corner)
    • +
    +
  • For k < 0, the k-th sub-diagonal is accessed (bottom-left corner)
    • +
    +
  • +An extracted diagonal is interpreted as a column vector +
    • +
    +
  • +Examples: +
      +
      +mat    X = randu<mat>(5,5);
+
+vec a = X.diag();
+vec b = X.diag(1);
+vec c = X.diag(-2);
+
+X.diag()  = randu<vec>(5);
+X.diag() += 6;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +element/object access via (), [] and .at() +
    +
  • +Provide access to individual elements or objects stored in a container object +(ie., Mat, Col, Row, Cube, field)
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + 
      (n)
      +       		 
      +       		+For vec and rowvec, access the n-th element. +For mat, cube and field, access the n-th element/object under the assumption of a flat layout, +with column-major ordering of data (ie. column by column). +A std::logic_error exception is thrown if the requested element is out of bounds. +The bounds check can be optionally disabled at compile-time (see below). +
         
      + 
      .at(n) and [n]
      +
      +       		+As for (n), but without a bounds check. +Not recommended for use unless your code has been thoroughly debugged. +
         
      + 
      (i,j)
      +
      +       		+For mat and field classes, access the element/object stored at the i-th row and j-th column. +A std::logic_error exception is thrown if the requested element is out of bounds. +The bounds check can be optionally disabled at compile-time (see below). +
         
      + 
      .at(i,j)
      +
      +       		+As for (i,j), but without a bounds check. +Not recommended for use unless your code has been thoroughly debugged. +
      +
         
      + 
      (i,j,k)
      +
      +       		+Cube only: access the element stored at the i-th row, j-th column and k-th slice. +A std::logic_error exception is thrown if the requested element is out of bounds. +The bounds check can be optionally disabled at compile-time (see below). +
         
      + 
      .at(i,j,k)
      +
      +       		+As for (i,j,k), but without a bounds check. +Not recommended for use unless your code has been thoroughly debugged.
      +
    +
    • +
    +
  • +The bounds checks used by the (n), (i,j) and (i,j,k) access forms +can be disabled by defining ARMA_NO_DEBUG or NDEBUG macros +before including the armadillo header file (eg. #define ARMA_NO_DEBUG). +Disabling the bounds checks is not recommended until your code has been thoroughly debugged +-- it's better to write correct code first, and then maximise its speed. +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(10,10);
+A(9,9) = 123.0;
+double x = A.at(9,9);
+double y = A[99];
+
+vec p = randu<vec>(10,1);
+p(9) = 123.0;
+double z = p[9];
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +element initialisation +
    +
  • +Instances of Mat, Col, Row and field classes can be initialised via repeated use of the << operator +
    • +
    +
  • +Special element endr indicates "end of row" (conceptually similar to std::endl) +
    • +
    +
  • +Setting elements via << is a bit slower than directly accessing the elements, +but code using << is generally more readable as well as being easier to write +
    • +
    +
  • +If you have a C++11 compiler, instances of Mat, Col and Row classes can be also initialised via initialiser lists; +this requires support for the C++11 standard to be explicitly enabled +
    • +
    +
  • +Examples: +
      +
      +mat A;
+
+A << 1 << 2 << 3 << endr
+  << 4 << 5 << 6 << endr;
+
+mat B = { 1, 2, 3, 4, 5, 6 };  // C++11 only
+B.reshape(2,3);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.eye() +
+.eye(n_rows, n_cols) +
    +
  • +Set the elements along the main diagonal to one and off-diagonal elements set to zero, +optionally first resizing to specified dimensions +
    • +
    +
  • +An identity matrix is generated when n_rows = n_cols +
    • +
    +
  • +Examples: +
      +
      +mat A(5,5);
+A.eye();
+
+mat B;
+B.eye(5,5);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +.fill(value) +
    +
  • +Member function of Mat, Col, Row and Cube classes. +
    • +
    +
  • Sets the elements to a specified value. +The type of value must match the type of elements used by the container object +(eg. for mat the type is double) +
    • +
    +
  • +Examples: +
      +
      +mat A(5,5);
+A.fill(123.0);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
.in_range( i )
+ 		(member of Mat, Col, Row, Cube and field) +
.in_range( span(start, end) )
+ 		(member of Mat, Col, Row, Cube and field) +
+   +
.in_range( row, col )
+ 		(member of Mat, Col, Row and field) +
.in_range( span(start_row, end_row), span(start_col, end_col) )
+ 		(member of Mat, Col, Row and field) +
+   +
.in_range( row, col, slice )
+ 		(member of Cube) +
.in_range( span(start_row, end_row), span(start_col, end_col), span(start_slice, end_slice) )
+ 		(member of Cube) +
+
+
    +
  • Returns true if the given location or span is currently valid +
    • +
    +
  • Returns false if the object is empty, the location is out of bounds, or the span is out of bounds +
    • +
    +
  • +Instances of span(a,b) can be replaced by: +
      +
    • span() or span::all, to indicate the entire range
      • +
    • span(a), to indicate a particular row, column or slice
      • +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+
+cout << A.in_range(0,0) << endl;  // true
+cout << A.in_range(3,4) << endl;  // true
+cout << A.in_range(4,5) << endl;  // false
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.is_empty() +
    +
  • +Member function of Mat, Col, Row, Cube and field classes +
    • +
    +
  • Returns true if the object has no elements +
    • +
    +
  • Returns false if the object has one or more elements +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+cout << A.is_empty() << endl;
+
+A.reset();
+cout << A.is_empty() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.is_finite() +
    +
  • +Member function of Mat, Col, Row and Cube classes +
    • +
    +
  • Returns true if all elements of the object are finite +
    • +
    +
  • Returns false if at least one of the elements of the object is non-finite (±infinity or NaN) +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = randu<mat>(5,5);
+
+B(1,1) = math::nan()
+
+cout << A.is_finite() << endl;
+cout << B.is_finite() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.is_square() +
    +
  • +Member function of the Mat class +
    • +
    +
  • Returns true if the matrix is square, ie., number of rows is equal to the number of columns +
    • +
    +
  • Returns false if the matrix is not square +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = randu<mat>(6,7);
+
+cout << A.is_square() << endl;
+cout << B.is_square() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +.is_vec() +
.is_colvec() +
.is_rowvec() +
    +
  • +Member functions of the Mat class +
    • +
    + +
  • .is_vec(): +
      +
    • Returns true if the matrix can be interpreted as a vector (either column or row vector) +
      • +
    • Returns false if the matrix does not have exactly one column or one row +
      • +
    +
    • +
    + +
  • .is_colvec(): +
      +
    • Returns true if the matrix can be interpreted as a column vector +
      • +
    • Returns false if the matrix does not have exactly one column +
      • +
    +
    • +
    + +
  • .is_rowvec(): +
      +
    • Returns true if the matrix can be interpreted as a row vector +
      • +
    • Returns false if the matrix does not have exactly one row +
      • +
    +
    • +
    + +
  • Caveat: do not assume that the vector has elements if these functions return true -- it is possible to have an empty vector (eg. 0x1) +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(1,5);
+mat B = randu<mat>(5,1);
+mat C = randu<mat>(5,5);
+
+cout << A.is_vec() << endl;
+cout << B.is_vec() << endl;
+cout << C.is_vec() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
+ .insert_rows( row_number, X ) +
+ .insert_rows( row_number, number_of_rows, set_to_zero = true ) +
(member functions of Mat and Col) +
 
+ .insert_cols( col_number, X ) +
+ .insert_cols( col_number, number_of_cols, set_to_zero = true ) +
(member functions of Mat and Row) +
 
+ .insert_slices( slice_number, X ) +
+ .insert_slices( slice_number, number_of_slices, set_to_zero = true ) +
(member functions of Cube) +
+
+
    +
  • +Functions with the X argument: insert a copy of X at the specified row/column/slice +
      +
    • if inserting rows, X must have the same number of columns as the recipient object
      • +
    • if inserting columns, X must have the same number of rows as the recipient object
      • +
    • if inserting slices, X must have the same number of rows and columns as the recipient object (ie. all slices must have the same size)
      • +
    +
    • +
    +
  • +Functions with the number_of_... argument: expand the object by creating new rows/columns/slices. +By default, the new rows/columns/slices are set to zero. +If set_to_zero is false, the memory used by the new rows/columns/slices will not be initialised. +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,10);
+mat B = ones<mat>(5,2);
+
+// at column 2, insert a copy of B;
+// A will now have 12 columns
+A.insert_cols(2, B);
+
+// at column 1, insert 5 zeroed columns;
+// B will now have 7 columns
+B.insert_cols(1, 5);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +iterators (matrices & vectors) +
    +
  • +STL-style iterators and associated member functions of the Mat, Col and Row classes +
    • +
    +
  • +iterator types: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + mat::iterator +
      + vec::iterator +
      + rowvec::iterator +       		 
      +       		+ random access iterators, for read/write access to elements + (which are stored column by column) +
      +   +  
      +       		+   +
      + mat::const_iterator +
      + vec::const_iterator +
      + rowvec::const_iterator +       		 
      +       		+ random access iterators, for read-only access to elements + (which are stored column by column) +
      +   +  
      +       		+   +
      + mat::col_iterator +
      + vec::col_iterator +
      + rowvec::col_iterator +       		 
      +       		+ random access iterators, for read/write access to the elements of a specific column +
      +   +  
      +       		+   +
      + mat::const_col_iterator +
      + vec::const_col_iterator +
      + rowvec::const_col_iterator +       		 
      +       		+ random access iterators, for read-only access to the elements of a specific column +
      +   +  
      +       		+   +
      + mat::row_iterator +  
      +       		+ rudimentary forward iterator, for read/write access to the elements of a specific row +
      +   +  
      +       		+   +
      + mat::const_row_iterator +  
      +       		+ rudimentary forward iterator, for read-only access to the elements of a specific row +
      +   +  
      +       		+   +
      + vec::row_iterator +
      + rowvec::row_iterator +       		 
      +       		+ random access iterators, for read/write access to the elements of a specific row +
      +   +  
      +       		+   +
      + vec::const_row_iterator +
      + rowvec::const_row_iterator +       		 
      +       		+ random access iterators, for read-only access to the elements of a specific row +
      +
    +
    • +
    +
    +
  • +Member functions: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + .begin() +  
      +       		+ iterator referring to the first element +
      + .end() +  
      +       		+ iterator referring to the past-the-end element +
      +   +
      + .begin_row(row_number) +  
      +       		+ iterator referring to the first element of the specified row +
      + .end_row(row_number) +  
      +       		+ iterator referring to the past-the-end element of the specified row +
      +   +
      + .begin_col(col_number) +  
      +       		+ iterator referring to the first element of the specified column +
      + .end_col(col_number) +  
      +       		+ iterator referring to the past-the-end element of the specified column +
      +
    +
    • +
    +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+
+
+mat::iterator a = X.begin();
+mat::iterator b = X.end();
+
+for(mat::iterator i=a; i!=b; ++i)
+  {
+  cout << *i << endl;
+  }
+
+
+mat::col_iterator c = X.begin_col(1);  // start of column 1
+mat::col_iterator d = X.end_col(3);    // end of column 3
+
+for(mat::col_iterator i=c; i!=d; ++i)
+  {
+  cout << *i << endl;
+  (*i) = 123.0;
+  }
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +iterators (cubes) +
    +
  • +STL-style iterators and associated member functions of the Cube class +
    • +
    +
  • +iterator types: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + cube::iterator +  
      +       		+ random access iterator, for read/write access to elements; + the elements are ordered slice by slice; + the elements within each slice are ordered column by column +
      +   +  
      +       		+   +
      + cube::const_iterator +  
      +       		+ random access iterators, for read-only access to elements +
      +   +  
      +       		+   +
      + cube::slice_iterator +  
      +       		+ random access iterator, for read/write access to the elements of a particular slice; + the elements are ordered column by column +
      +   +  
      +       		+   +
      + cube::const_slice_iterator +  
      +       		+ random access iterators, for read-only access to the elements of a particular slice +
      +
    +
    • +
    +
    +
  • +Member functions: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + .begin() +  
      +       		+ iterator referring to the first element +
      + .end() +  
      +       		+ iterator referring to the past-the-end element +
      +   +
      + .begin_slice(slice_number) +  
      +       		+ iterator referring to the first element of the specified slice +
      + .end_slice(slice_number) +  
      +       		+ iterator referring to the past-the-end element of the specified slice +
      +
    +
    • +
    +
    +
  • +Examples: +
      +
      +cube X = randu<cube>(2,3,4);
+
+
+cube::iterator a = X.begin();
+cube::iterator b = X.end();
+
+for(cube::iterator i=a; i!=b; ++i)
+  {
+  cout << *i << endl;
+  }
+
+
+cube::slice_iterator c = X.begin_slice(1);  // start of slice 1
+cube::slice_iterator d = X.end_slice(2);    // end of slice 2
+
+for(cube::slice_iterator i=c; i!=d; ++i)
+  {
+  cout << *i << endl;
+  (*i) = 123.0;
+  }
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.memptr() +
    +
  • +Member function of Mat, Col, Row and Cube classes +
    • +
    +
  • +Obtain a raw pointer to the memory used for storing elements. Not recommended for use unless you know what you're doing! +
    • +
    +
  • +The function can be used for interfacing with libraries such as FFTW +
    • +
    +
  • +As soon as the size of the matrix/vector/cube is changed, the pointer is no longer valid +
    • +
    +
  • +Data for matrices is stored in a column-by-column order +
    • +
    +
  • +Data for cubes is stored in a slice-by-slice (matrix-by-matrix) order +
    • +
    +
  • +Examples: +
      +
      +      mat A = randu<mat>(5,5);
+const mat B = randu<mat>(5,5);
+
+      double* A_mem = A.memptr();
+const double* B_mem = B.memptr();
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
.min()
+ 		(member functions of Mat, Col, Row, Cube) +
.max()
+ 		  +
 
+ 		  +
.min( index_of_min_val )
+ 		(member functions of Mat, Col, Row, Cube) +
.max( index_of_max_val )
+ 		  +
 
+ 		  +
.min( row_of_min_val, col_of_min_val )
+ 		(member functions of Mat) +
.max( row_of_max_val, col_of_max_val )
+ 		  +
 
+ 		  +
.min( row_of_min_val, col_of_min_val, slice_of_min_val )
+ 		(member functions of Cube) +
.max( row_of_max_val, col_of_max_val, slice_of_max_val )
+ 		  +
+
    +
    +
  • +Without arguments: return the extremum value of an object +
    • +
    +
  • +With one or more arguments: return the extremum value of an object and store the location of the extremum value in the provided variable(s) +
    • +
    +
  • +The provided variables must be of type uword. +
    • +
    +
  • +Examples: +
      +
      +vec v = randu<vec>(10);
+
+cout << "min value is " << v.min() << endl;
+
+
+uword  index;
+double min_val = v.min(index);
+
+cout << "index of min value is " << index << endl;
+
+
+mat A = randu<mat>(5,5);
+
+uword  row;
+uword  col;
+double min_val2 = A.max(row,col);
+
+cout << "max value is at " << row << ',' << col << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.ones() +
.ones(n_elem) +
.ones(n_rows, n_cols) +
.ones(n_rows, n_cols, n_slices) +
    +
  • +Set the elements of an object to one, optionally first resizing to specified dimensions +
    • +
    +
  • +.ones() and .ones(n_elem) are member functions of Col and Row +
    • +
    +
  • +.ones() and .ones(n_rows, n_cols) are member functions of Mat +
    • +
    +
  • +.ones() and .ones(n_rows, n_cols, n_slices) are member functions of Cube +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,10);
+A.ones();      // sets all elements to one
+A.ones(10,20); // sets the size to 10 rows and 20 columns
+               // followed by setting all elements to one
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +operators:   +   -   *   /   %   ==   !=   <=   >=   <   > +
    +
  • +Overloaded operators for mat, vec, rowvec and cube classes +
    • +
    +
  • +Meanings: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      +   
      +       		Addition of two objects
      -
      +       		Subtraction of one object from another or negation of an object
      /
      +       		Element-wise division of an object by another object or a scalar
      *
      +       		Matrix multiplication of two objects; not applicable to the cube class unless multiplying a cube by a scalar
      %
      +       		Schur product: element-wise multiplication of two objects
      ==
      +       		Element-wise equality evaluation of two objects; generates a matrix of type umat with entries that indicate whether at a given position the two elements from the two objects are equal (1) or not equal (0)
      !=
      +       		Element-wise non-equality evaluation of two objects
      >=
      +       		As for ==, but the check is for "greater than or equal to"
      <=
      +       		As for ==, but the check is for "less than or equal to"
      >
      +       		As for ==, but the check is for "greater than"
      <
      +       		As for ==, but the check is for "less than"
      +
    +
    • +
    +
  • +A std::logic_error exception is thrown if incompatible object sizes are used +
    • +
    +
  • +If the +, - and % operators are chained, Armadillo will try to avoid the generation of temporaries; +no temporaries are generated if all given objects are of the same type and size +
    • +
    +
  • +If the * operator is chained, Armadillo will try to find an efficient ordering of the matrix multiplications +
    • +
    +
  • +Caveat: operators involving an equality comparison (ie., ==, !=, >=, <=) +may not work as expected for floating point element types (ie., float, double) +due to the necessarily limited precision of these types; +in other words, these operators are (in general) not recommended for matrices of type mat or fmat +
    • +
    +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,10);
+mat B = randu<mat>(5,10);
+mat C = randu<mat>(10,5);
+
+mat P = A + B;
+mat Q = A - B;
+mat R = -B;
+mat S = A / 123.0;
+mat T = A % B;
+mat U = A * C;
+
+// V is constructed without temporaries
+mat V = A + B + A + B;
+
+imat AA = "1 2 3; 4 5 6; 7 8 9;";
+imat BB = "3 2 1; 6 5 4; 9 8 7;";
+
+// compare elements
+umat ZZ = (AA >= BB);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.print(header="") +
.print(stream, header="") +
    +
  • +Member function of Mat, Col, Row, Cube and field +
    • +
    +
  • +The first form prints the contents of an object to the std::cout stream, with an optional header line +
    • +
    +
  • +The second form prints to a user specified stream +
    • +
    +
  • +It's also possible to print objects using the << stream operator +
    • +
    +
  • +Elements of a field can only be printed if there is an associated operator<< function defined +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = randu<mat>(6,6);
+
+A.print();
+
+// print a transposed version of A
+A.t().print();
+
+// "B:" is the optional header line
+B.print("B:");
+
+cout << A << endl;
+cout << "B:" << endl << B << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.raw_print(header="") +
.raw_print(stream, header="") +
    +
  • +Member function of Mat, Col, Row and Cube +
    • +
    +
  • +Similar to the .print() member function, +with the difference being that no formatting of the output is done -- ie. the user can set the stream's parameters such as precision, cell width, etc. +
    • +
    +
  • +If the cell width is set to zero, a space is printed between the elements +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+cout.precision(11);
+cout.setf(ios::fixed);
+
+A.raw_print(cout, "A =");
+
      +
    +
    • +
+
+

+ + +.randu() +
.randu(n_elem) +
.randu(n_rows, n_cols) +
.randu(n_rows, n_cols, n_slices) +
+
+.randn() +
.randn(n_elem) +
.randn(n_rows, n_cols) +
.randn(n_rows, n_cols, n_slices) +
    +
  • +Fill an object with random values, optionally first resizing to specified dimensions +
    • +
    +
  • .randu() uses a uniform distribution in the [0,1] interval +
    • +
    +
  • .randn() uses a normal/Gaussian distribution with zero mean and unit variance +
    • +
    +
  • +To change the seed, use the std::srand() function +
    • +
    +
  • +Examples: +
      +
      +mat A(4,5);
+A.randu();
+
+mat B;
+B.randu(6,7);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +.reset() + +
    +
  • +Member function of Mat, Col, Row, Cube and field +
    • +
    +
  • +Causes an object to have no elements +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5, 5);
+A.reset();
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + + + + + + + + + + + + + + +
.reshape(n_rows, n_cols, dim=0)
+ 		(member function of Mat, Col, Row) +
.reshape(n_rows, n_cols, n_slices, dim=0)
+ 		(member function of Cube) +
+
+
    +
  • +Recreate the object according to given size specifications, +with the elements taken from the previous version of the object, +either column-wise (dim=0) or row-wise (dim=1); +the elements in the generated object are placed column-wise (ie. the first column is filled up before filling the second column) +
    • +
    +
  • +The layout of the elements in the recreated object will be different to the layout in the previous version of the object +
    • +
    +
  • +This function can be used to vectorise a matrix (ie. concatenate all the columns or rows) +
    • +
    +
  • +The new total number of elements (according to the specified size) doesn't have to be the same as the previous total number of elements in the object +
    • +
    +
  • +If the total number of elements in the previous version of the object is less than the specified size, +the extra elements in the recreated object are set to zero +
    • +
    +
  • +If the total number of elements in the previous version of the object is greater than the specified size, +only a subset of the elements is taken +
    • +
    +
  • +Caveat: +.reshape() is slower than .set_size(), which doesn't preserve data +
    • +
    +
  • +Caveat: +if you wish to grow/shrink the object while preserving the elements as well as the layout of the elements, +use .resize() instead +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+A.reshape(5,4);
+
+// vectorise A into a column vector:
+A.reshape(A.n_elem, 1);
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + + + + + + + + + + + + + + + + + + + +
.resize(n_elem)
+ 		(member function of Col, Row) +
.resize(n_rows, n_cols)
+ 		(member function of Mat) +
.resize(n_rows, n_cols, n_slices)
+ 		(member function of Cube) +
+
+
    +
  • +Recreate the object according to given size specifications, while preserving the elements as well as the layout of the elements +
    • +
    +
  • +Can be used for growing or shrinking an object (ie. adding/removing rows, and/or columns, and/or slices) +
    • +
    +
  • +Caveat: +.resize() is slower than .set_size(), which doesn't preserve data +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+A.resize(7,6);
+
      +
    +
    • +
    +
  • +This function was added in version 2.4.1 +
    • +
    +
  • See also: + +
    • +
+
+

+ + + +.save(name, file_type = arma_binary) +
+.save(stream, file_type = arma_binary) +
+
+.load(name, file_type = auto_detect) +
+.load(stream, file_type = auto_detect) +
+
+.quiet_save(name, file_type = arma_binary) +
+.quiet_save(stream, file_type = arma_binary) +
+
+.quiet_load(name, file_type = auto_detect) +
+.quiet_load(stream, file_type = auto_detect) + +
    +
  • Member functions of Mat, Col, Row and Cube classes
    • +
    +
  • Store/retrieve data in files or streams
    • +
    +
  • On success, save(), load(), quiet_save(), and quite_load() will return a bool set to true
    • +
    +
  • save() and quiet_save() will return a bool set to false if the saving process fails
    • +
    +
  • +load() and quiet_load() will return a bool set to false if the loading process fails; +additionally, the object will be reset so it has no elements +
    • +
    +
  • load() and save() will print warning messages if any problems are encountered
    • +
    +
  • quiet_load() and quiet_save() do not print any error messages
    • +
    +
  • +The following file formats are supported: +
    +
    +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      auto_detect
      +       		+for load() and quiet_load(): +try to automatically detect the file type as one of the formats described below. +This is the default operation. +
      +
      +
      raw_ascii
      +       		+Numerical data stored in raw ASCII format, without a header. +The numbers are separated by whitespace. +The number of columns must be the same in each row. +Data which was saved in Matlab/Octave using the -ascii option can be read in Armadillo, except for complex numbers. +Complex numbers are stored in standard C++ notation (a tuple surrounded by brackets: eg. (1.23,4.56) indicates 1.24 + 4.56i). +Cubes are loaded as one slice. +
      +
      +
      raw_binary
      +       		+Numerical data stored in machine dependent raw binary format, without a header. +Matrices are loaded to have one column, +while cubes are loaded to have one slice with one column. +The .reshape() function can be used to alter the size of the loaded matrix/cube without losing data. +
      +
      +
      arma_ascii
      +       		+Numerical data stored in human readable text format, with a simple header to speed up loading. +The header indicates the type of matrix as well as the number of rows and columns. +For cubes, the header additionally specifies the number of slices. +
      +
      +
      arma_binary
      +       		+Numerical data stored in machine dependent binary format, with a simple header to speed up loading. +The header indicates the type of matrix as well as the number of rows and columns. +For cubes, the header additionally specifies the number of slices. +
      +
      +
      csv_ascii
      +       		+Numerical data stored in comma separated value (CSV) text format, without a header. +Applicable to Mat only. +
      +
      +
      pgm_binary
      +       		+Image data stored in Portable Gray Map (PGM) format. +Applicable to Mat only. +Saving int, float or double matrices is a lossy operation, as each element is copied and converted to an 8 bit representation. +As such the matrix should have values in the [0,255] interval, otherwise the resulting image may not display correctly. +
      +
      +
      ppm_binary
      +       		+Image data stored in Portable Pixel Map (PPM) format. +Applicable to Cube only. +Saving int, float or double matrices is a lossy operation, as each element is copied and converted to an 8 bit representation. +As such the cube/field should have values in the [0,255] interval, otherwise the resulting image may not display correctly. +
      +
    +
    • +
    +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+A.save("A1.mat");  // default save format is arma_binary
+A.save("A2.mat", arma_ascii);
+
+mat B;
+// automatically detect format type
+B.load("A1.mat");
+
+mat C;
+// force loading in the arma_ascii format
+C.load("A2.mat", arma_ascii);
+
+
+// example of saving/loading using a stream
+std::stringstream s;
+A.save(s);
+
+mat D;
+D.load(s);
+
+
+// example of testing for success
+mat E;
+bool status = E.load("A2.mat");
+
+if(status == true)
+  {
+  cout << "loaded okay" << endl;
+  }
+else
+  {
+  cout << "problem with loading" << endl;
+  }
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + + +.save(name, file_type = arma_binary) +
+.save(stream, file_type = arma_binary) +
+
+.load(name, file_type = auto_detect) +
+.load(stream, file_type = auto_detect) +
+
+.quiet_save(name, file_type = arma_binary) +
+.quiet_save(stream, file_type = arma_binary) +
+
+.quiet_load(name, file_type = auto_detect) +
+.quiet_load(stream, file_type = auto_detect) + +
    +
  • Member functions of the field class
    • +
    +
  • Store/retrieve fields in files or stream
    • +
    +
  • On success, save(), load(), quiet_save(), and quite_load() will return a bool set to true
    • +
    +
  • save() and quiet_save() will return a bool set to false if the saving process fails
    • +
    +
  • +load() and quiet_load() will return a bool set to false if the loading process fails; +additionally, the field will be reset so it has no elements +
    • +
    +
  • load() and save() will print warning messages if any problems are encountered
    • +
    +
  • quiet_load() and quiet_save() do not print any error messages
    • +
    +
  • +Fields with objects of type std::string are saved and loaded as raw text files. +The text files do not have a header. +Each string is separated by a whitespace. +load() and quiet_load() will only accept text files that have the same number of strings on each line. +The strings can have variable lengths. +
    • +
    +
  • +Other than storing string fields as text files, the following file formats are supported: +
    +
    +
      + + + + + + + + + + + + + + + + + + +
      auto_detect
      +       		+
      +
    • +load(): try to automatically detect the field format type as one of the formats described below. +This is the default operation. +
      • +
      +
      arma_binary
      +       		+
      +
    • +Objects are stored in machine dependent binary format. +
    • +Default type for fields of type Mat, Col or Row. +
      • +
    • +Only applicable to fields of type Mat, Col or Row. +
      • +
      +
      ppm_binary
      +       		+
      +
    • +Image data stored in Portable Pixmap Map (PPM) format. +
      • +
    • +Only applicable to fields of type Mat, Col or Row. +
      • +
    • +.load(): Loads the specified image and stores the red, green and blue components as three separate matrices. +The resulting field is comprised of the three matrices, +with the red, green and blue components in the first, second and third matrix, respectively. +
      • +
    • +.save(): Saves a field with exactly three matrices of equal size as an image. +It is assumed that the red, green and blue components are stored in the first, second and third matrix, respectively. +Saving int, float or double matrices is a lossy operation, +as each matrix element is copied and converted to an 8 bit representation. +
      • + +
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +.set_imag(X) +
+.set_real(X) +
+
    +
  • Member functions of Mat, Col, Row and Cube
    • +
    +
  • +Set the imaginary/real part of an object +
    • +
    +
  • +X must have the same size as the recipient object +
    • +
    +
  • +Examples: +
      +
      +   mat A = randu<mat>(4,5);
+   mat B = randu<mat>(4,5);
+
+cx_mat C = zeros<mat>(4,5);
+
+C.set_real(A);
+C.set_imag(B);
+
      +
    +
    • +
    +
  • +Caveat: +if you want to directly construct a complex matrix out of two real matrices, +the following code is faster: +
      +
      +   mat A = randu<mat>(4,5);
+   mat B = randu<mat>(4,5);
+
+cx_mat C = cx_mat(A,B);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + + + + + + + + + + + + + + + + + + + +
.set_size(n_elem)
+ 		(member function of Col, Row, and field) +
.set_size(n_rows, n_cols)
+ 		(member function of Mat and field) +
.set_size(n_rows, n_cols, n_slices)
+ 		(member function of Cube) +
+
+
    +
  • Changes the size of an object
    • +
    +
  • +If the requested number of elements is equal to the old number of elements, existing memory is reused +
    • +
    +
  • +If the requested number of elements is not equal to the old number of elements, new memory is used +
    • +
    +
  • +If you need to explicitly preserve data, use .reshape() or .resize() +
    • +
    +
  • +Examples: +
      +
      +mat A;
+A.set_size(5,10);
+
+vec q;
+q.set_size(100);
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
+ .shed_row( row_number ) +
+ .shed_rows( first_row, last_row ) +
(member functions of Mat and Col) +
 
+ .shed_col( column_number ) +
+ .shed_cols( first_column, last_column ) +
(member functions of Mat and Row) +
 
+ .shed_slice( slice_number ) +
+ .shed_slices( first_slice, last_slice ) +
(member functions of Cube) +
+
+ +

+ + +STL container functions +
    +
  • Mat, Col and Row classes provide the following member functions that mimic the containers in the C++ Standard Template Library:
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + .clear() +  
    +     		+ causes an object to have no elements +
    +   +  
    +     		+   +
    + .empty() +  
    +     		+ returns true if the object has no elements; returns false if the object has one or more elements +
    +   +  
    +     		+   +
    + .size() +  
    +     		+ returns the total number of elements +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+cout << A.size() << endl;
+
+A.clear();
+cout << A.empty() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +submatrix views +
    +
  • A collection of member functions of Mat, Col and Row classes that provide submatrix views
    +
    +
  • For a matrix or vector X, the subviews are accessed as:
    • +
    +
      +X.col( col_number )
      +X( span::all, col_number )
      +X( span(first_row, last_row), col_number )
      +
      +X.unsafe_col( col_number )
      +
      +X.row( row_number )
      +X( row_number, span::all )
      +X( row_number, span(first_col, last_col) )
      +
      +X.cols( first_col, last_col )
      +X.rows( first_row, last_row )
      +
      +X.submat( first_row, first_col, last_row, last_col )
      +X.submat( span(first_row, last_row), span(first_col, last_col) )
      +
      +X( span(first_row, last_row), span(first_col, last_col) )
      +
      +X.elem( vector_of_indices ) +
    + +
    +
  • For a vector V (column or row vector), there is an additional method:
    • + +
    +
      +V.subvec( first_index, last_index )
      + +
    +
    +
  • +Instances of span::all, to indicate an entire range, can be replaced by span(), where no number is specified +
    • +
    +
  • +In the function X.elem(vector_of_indices), +elements specified in vector_of_indices are accessed. +X is interpreted as one long vector, +with column-by-column ordering of the elements of X. +The vector_of_indices must evaluate to be a vector of type uvec +(eg., generated by find()). +The aggregate set of the specified elements is treated as a column vector +(eg., the output of X.elem() is always a column vector). +
    • +
    +
  • +The function .unsafe_col() is provided for speed reasons and should be used only if you know what you're doing. +The function creates a seemingly independent Col vector object (eg. vec), +but the vector actually uses memory from the existing matrix object. +As such, the created Col vector is currently not alias safe +and does not take into account that the parent matrix object could be deleted. +If deleted memory is accessed through the created Col vector, +it will cause memory corruption and/or a crash. +
    • +
    +
  • +Examples: +
      +
      +mat A = zeros<mat>(5,10);
+
+A.submat(0,1,2,3) = randu<mat>(3,3);
+
+// the following three statements
+// access the same part of A
+mat B = A.submat(0,1,2,3);
+mat C = A.submat( span(0,2), span(1,3) );
+mat D = A( span(0,2), span(1,3) );
+
+// the following two statements
+// access the same part of A
+A.col(1)        = randu<mat>(5,1);
+A(span::all, 1) = randu<mat>(5,1);
+
+mat X = randu<mat>(5,5);
+
+// get all elements of X that are greater than 0.5
+vec q = X.elem( find(X > 0.5) );
+
+// set four specific elements of X to 1
+uvec indices;
+indices << 2 << 3 << 6 << 8;
+
+X.elem(indices) = ones<vec>(4);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +subcube views and slices +
    +
  • A collection of member functions of the Cube class that provide subcube views
    +
    +
  • For a cube Q, the subviews are accessed as:
    • +
    +
      +Q.slice( slice_number )
      +Q.slices( first_slice, last_slice )
      +
      +Q.subcube( first_row, first_col, first_slice, last_row, last_col, last_slice )
      +Q.subcube( span(first_row, last_row), span(first_col, last_col), span(first_slice, last_slice) )
      +
      +Q( span(first_row, last_row), span(first_col, last_col), span(first_slice, last_slice) )
      +
    + +
    +
  • +Instances of span(a,b) can be replaced by: +
      +
    • span() or span::all, to indicate the entire range
      • +
    • span(a), to indicate a particular row, column or slice
      • +
    +
    • +
    +
  • +An individual slice, accessed via .slice(), is an instance of the Mat class +(a reference to a matrix is provided) +
    • +
    +
  • +Examples: +
      +
      +cube A = randu<cube>(2,3,4);
+mat B = A.slice(1);
+
+A.slice(0) = randu<mat>(2,3);
+A.slice(0)(1,2) = 99.0;
+
+A.subcube(0,0,1,  1,1,2) = randu<cube>(2,2,2);
+A( span(0,1), span(0,1), span(1,2) ) = randu<cube>(2,2,2);
+
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +subfield views +
    +
  • A collection of member functions of the field class that provide subfield views
    +
    +
  • For a field F, the subfields are accessed as:
    • +
    +
      +F.row( row_number )
      +F.col( col_number )
      +
      +F.rows( first_row, last_row )
      +F.cols( first_col, last_col )
      +
      +F.subfield( first_row, first_col, last_row, last_col )
      +F.subfield( span(first_row, last_row), span(first_col, last_col) )
      +
      +F( span(first_row, last_row), span(first_col, last_col) )
      +
    + +
    +
  • +Instances of span(a,b) can be replaced by: +
      +
    • span() or span::all, to indicate the entire range
      • +
    • span(a), to indicate a particular row or column
      • +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +.swap_rows(row1, row2) +
.swap_cols(col1, col2) + +
    +
  • +Member functions of Mat, Col and Row classes +
    • +
    +
  • +Swap the contents of specified rows or columns +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+X.swap_rows(0,4);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +.t() +
.st() + +
    +
  • +Member functions of any expression involving matrices or vectors +
    • +
    +
  • +.t() provides a transposed copy of the object; if a given object has complex elements, a Hermitian transpose is done (ie. the conjugate of the elements is taken during the transpose operation) +
    • +
    +
  • +.st() provides a transposed copy of the object, without taking the conjugate of the elements (complex matrices) +
    • +
    +
  • +For non-complex objects, the .t() and .st() functions are equivalent +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+mat B = A.t();
+
      +
    +
    • +
    +
  • +The .t() and .st() functions were added in version 2.4 +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +.zeros() +
.zeros(n_elem) +
.zeros(n_rows, n_cols) +
.zeros(n_rows, n_cols, n_slices) +
    +
  • +Set the elements of an object to zero, optionally first resizing to specified dimensions +
    • +
    +
  • +.zeros() and .zeros(n_elem) are member function of Col and Row +
    • +
    +
  • +.zeros() and .zeros(n_rows, n_cols) are member functions of Mat +
    • +
    +
  • +.zeros() and .zeros(n_rows, n_cols, n_slices) are member functions of Cube +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,10);
+A.zeros();      // sets all elements to zero
+A.zeros(10,20); // sets the size to 10 rows and 20 columns
+                // followed by setting all elements to zero
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+
+ + +
+
+
+Other Classes +
+
+
+
+ + +running_stat<type> +
    +
  • +Class for keeping statistics of a continuously sampled one dimensional process/signal. +Useful if the storage of individual samples (scalars) is not necessary or desired. +Also useful if the number of samples is not known beforehand or exceeds available memory. +
    • +
    +
  • +type should be one of: float, double, cx_float, cx_double +
    • +
    +
  • +Member functions: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + .operator()(scalar) +  
      +       		+ update the statistics so far using the given scalar +
      + .mean() +  
      +       		+ get the mean or average value so far +
      + .var(norm_type=0) +  
      +       		+ get the variance so far +
      + .stddev(norm_type=0) +  
      +       		+ get the standard deviation so far +
      + .min() +  
      +       		+ get the minimum value so far +
      + .max() +  
      +       		+ get the maximum value so far +
      + .reset() +  
      +       		+ reset all statistics and set the number of samples to zero +
      + .count() +  
      +       		+ get the number of samples so far +
      +
    +
    • +
    +
  • +For the .var() and .stddev() functions, the default norm_type=0 performs normalisation using N-1 +(where N is the number of samples so far), +providing the best unbiased estimator. +Using norm_type=1 causes normalisation to be done using N, which provides the second moment around the mean. +
    • +
    +
  • +The return type of .count() depends on the underlying form of type: it is either float or double. +
    • +
    +
  • +Examples: +
      +
      +running_stat<double> stats;
+
+for(uword i=0; i<10000; ++i)
+  {
+  double sample = double(rand())/RAND_MAX;
+  stats(sample);
+  }
+
+cout << "mean = " << stats.mean() << endl;
+cout << "var  = " << stats.var()  << endl;
+cout << "min  = " << stats.min()  << endl;
+cout << "max  = " << stats.max()  << endl;
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + +running_stat_vec<type>(calc_cov = false) +
    +
  • +Class for keeping statistics of a continuously sampled multi-dimensional process/signal. +Useful if the storage of individual samples is not necessary or desired. +Also useful if the number of samples is not known beforehand or exceeds available memory. +
    • +
    +
  • +This class is similar to running_stat, with the difference being that vectors are processed instead of single values. +
    • +
    +
  • +type must match the element type used by the sample vectors +(ie. it must be one of float, double, cx_float, cx_double) +
    • +
    +
  • +type can be inferred via the use of the elem_type member typedef of a vector class. +For example, fvec::elem_type will be interpreted as float, +while cx_vec::elem_type will be interpreted as cx_double. +
    • +
    +
  • +Member functions: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + .operator()(vector) +  
      +       		+ update the statistics so far using the given vector +
      + .mean() +  
      +       		+ get the mean vector so far +
      + .var(norm_type=0) +  
      +       		+ get the vector of variances so far +
      + .stddev(norm_type=0) +  
      +       		+ get the vector of standard deviations so far +
      + .min() +  
      +       		+ get the vector of minimum values so far +
      + .max() +  
      +       		+ get the vector of maximum values so far +
      + .cov(norm_type=0) +  
      +       		+ get the covariance matrix so far +
      NOTE: this only works if calc_cov is set to true during the construction of the class +
      + .reset() +  
      +       		+ reset all statistics and set the number of samples to zero +
      + .count() +  
      +       		+ get the number of samples so far +
      +
    +
    • +
    +
  • +For the .var() and .stddev() functions, the default norm_type=0 performs normalisation using N-1 +(where N is the number of samples so far), +providing the best unbiased estimator. +Using norm_type=1 causes normalisation to be done using N, which provides the second moment around the mean. +
    • +
    +
  • +The return type of .count() depends on the underlying form of type: it is either float or double. +
    • +
    +
  • +Examples: +
      +
      +running_stat_vec<rowvec::elem_type> stats;
+
+rowvec sample;
+
+for(uword i=0; i<10000; ++i)
+  {
+  sample = randu<rowvec>(5);
+  stats(sample);
+  }
+
+cout << "mean = " << stats.mean() << endl;
+cout << "var  = " << stats.var()  << endl;
+cout << "min  = " << stats.min()  << endl;
+cout << "max  = " << stats.max()  << endl;
+
+//
+//
+
+running_stat_vec<rowvec::elem_type> more_stats(true);
+
+for(uword i=0; i<20; ++i)
+  {
+  sample = randu<rowvec>(3);
+  
+  sample(1) -= sample(0);
+  sample(2) += sample(1);
+  
+  more_stats(sample);
+  }
+
+cout << "covariance matrix = " << endl;
+cout << more_stats.cov() << endl;
+
+rowvec sd = more_stats.stddev();
+
+cout << "correlations = " << endl;
+cout << more_stats.cov() / (trans(sd) * sd);
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + +wall_clock +
    +
  • +Simple wall clock timer class, for measuring the number of elapsed seconds between two intervals +
    • +
    +
  • +Examples: +
      +
      +wall_clock timer;
+
+mat A = randu<mat>(4,4);
+mat B = randu<mat>(4,4);
+mat C;
+
+timer.tic();
+for(uword i=0; i<100000; ++i)
+  C = A + B + A + B;
+
+double n_secs = timer.toc();
+cout << "took " << n_secs << " seconds" << endl;
+
      +
    +
    • +
+
+
+ +
+
+
+Generated Vectors/Matrices +
+
+
+
+ + +eye(n_rows, n_cols) +
    +
  • +Generate a matrix with the elements along the main diagonal set to one +and off-diagonal elements set to zero +
    • +
    +
  • +An identity matrix is generated when n_rows = n_cols +
    • +
    +
  • +Usage: +
      +
    • +matrix_type X = eye<matrix_type>(n_rows, n_cols) +
      • +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = eye<mat>(5,5);
+mat B = 123.0 * eye<mat>(5,5);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +linspace(start, end, N=100) +
    +
  • +Generate a vector with N elements; +the values of the elements linearly increase from start upto (and including) end +
    +
    • +
    +
  • +Usage: +
      +
    • vector_type v = linspace<vector_type>(start, end, N)
      • +
    • matrix_type X = linspace<matrix_type>(start, end, N)
      • +
    +
    • +
    +
  • +If a matrix_type is specified, the resultant matrix will have one column +
    • +
    +
  • +Examples: +
      +
      +vec v = linspace<vec>(10, 20, 5);
+mat X = linspace<mat>(10, 20, 5);
+
      +
    +
    • +
+
+

+ + + +ones(n_elem) +
ones(n_rows, n_cols) +
ones(n_rows, n_cols, n_slices) + +
    +
  • +Generate a vector, matrix or cube with all elements set to one +
    • +
    +
  • +Usage: +
      +
    • vector_type v = ones<vector_type>(n_elem)
      • +
    • matrix_type X = ones<matrix_type>(n_rows, n_cols)
      • +
    • cube_type Q = ones<cube_type>(n_rows, n_cols, n_slices)
      • +
    +
    • +
    +
  • +Examples: +
      +
      +vec  v = ones<vec>(10);
+mat  A = ones<mat>(5,6);
+cube Q = ones<cube>(5,6,7);
+
+mat  B = 123.0 * ones<mat>(5,6);
+
      +
    +
    • +
    +
  • +See also: +
      +
    • .ones() (member function of Mat, Col, Row and Cube)
      • +
    • eye()
      • +
    +
    • +
+
+

+ + +randu(n_elem) +
randu(n_rows, n_cols) +
randu(n_rows, n_cols, n_slices) +
+
randn(n_elem) +
randn(n_rows, n_cols) +
randn(n_rows, n_cols, n_slices) +
    +
  • +Generate a vector, matrix or cube with the elements set to random values +
    • +
    +
  • randu() uses a uniform distribution in the [0,1] interval +
    • +
    +
  • randn() uses a normal/Gaussian distribution with zero mean and unit variance +
    • +
    +
  • +Usage: +
      +
    • vector_type v = randu<vector_type>(n_elem)
      • +
    • matrix_type X = randu<matrix_type>(n_rows, n_cols)
      • +
    • cube_type Q = randu<cube_type>(n_rows, n_cols, n_slices)
      • +
    +
    • +
    +
  • +To change the seed, use the std::srand() function. +
    • +
    +
  • +Examples: +
      +
      +vec  v = randu<vec>(5);
+mat  A = randu<mat>(5,6);
+cube Q = randu<cube>(5,6,7);
+
      +
    +
    • +
  • See also: + +
    • +
    +
+

+ + +repmat(A, num_copies_per_row, num_copies_per_col) +
    +
  • Generate a matrix by replicating matrix A in a block-like fashion
    • +
    +
  • The generated matrix has the following size: +
      +rows = num_copies_per_row * A.n_rows +
      +cols = num_copies_per_col * A.n_cols +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(2, 3);
+
+mat B = repmat(A, 4, 5);
+
      +
    +
    • +
    +
+
+
+ + +toeplitz(A) +
toeplitz(A,B) +
circ_toeplitz(A) +
    +
  • +toeplitz(): generate a Toeplitz matrix, with the first column specified by A, and (optionally) the first row specified by B +
    • +
    +
  • +circ_toeplitz(): generate a circulant Toeplitz matrix +
    • +
    +
  • +A and B must be vectors +
    • +
    +
  • +Examples: +
      +
      +vec A = randu<vec>(5);
+mat X = toeplitz(A);
+mat Y = circ_toeplitz(A);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+
+
+ + +zeros(n_elem) +
zeros(n_rows, n_cols) +
zeros(n_rows, n_cols, n_slices) +
    +
  • +Generate a vector, matrix or cube with the elements set to zero +
    • +
    +
  • +Usage: +
      +
    • vector_type v = zeros<vector_type>(n_elem)
      • +
    • matrix_type X = zeros<matrix_type>(n_rows, n_cols)
      • +
    • cube_type X = zeros<cube_type>(n_rows, n_cols, n_slices)
      • +
    +
    • +
    +
  • +Examples: +
      +
      +vec  v = zeros<vec>(5);
+mat  A = zeros<mat>(5,6);
+cube Q = zeros<cube>(5,6,7);
+
      +
    +
    • +
    +
  • +See also: +
      +
    • .zeros() (member function of Mat, Col, Row and Cube)
      • +
    • .ones() (member function of Mat, Col, Row and Cube)
      • +
    • ones()
      • +
    +
    • +
+
+
+ +
+
+
+Functions Individually Applied to Each Element of a Matrix/Cube +
+
+
+
+ + +abs(mat) +
abs(cube) +
abs(cx_mat) +
abs(cx_cube) +
    +
  • +Obtain the magnitude of each element +
    • +
    +
  • +Usage for non-complex matrices: +
      +
    • matrix_type Y = abs(X)
      • +
    • X and Y must have the same matrix_type
      • +
    +
    • +
    +
  • +Usage for non-complex cubes: +
      +
    • cube_type Y = abs(X)
      • +
    • X and Y must have the same cube_type
      • +
    +
    • +
    +
  • +Usage for complex matrices: +
      +
    • non_complex_matrix_type Y = abs(X)
      • +
    • X must be a have complex matrix type, eg., cx_mat or cx_fmat
      • +
    • The type of Y must be related to the type of X, +eg., if X has the type cx_mat, then the type of Y must be mat +
    +
    • +
    +
  • +Usage for complex cubes: +
      +
    • non_complex_cube_type Y = abs(X)
      • +
    • X must be a have complex cube type, eg., cx_cube or cx_fcube
      • +
    • The type of Y must be related to the type of X, +eg., if X has the type cx_cube, then the type of Y must be cube +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = abs(A); 
+
+cx_mat X = randu<cx_mat>(5,5);
+mat    Y = abs(X);
+
      +
    +
    • +
+
+

+ + +eps(X) + +
+

+ + + +miscellaneous functions: +
  exp, exp2, exp10, trunc_exp, +
  log, log2, log10, trunc_log, +
  pow, sqrt, square +
  floor, ceil + +
+
    +
  • +Apply a function to each element +
    • +
    +
  • +Usage: +
      +
    • +matrix_type B = misc_fn(A) +
      • +
    • +cube_type B = misc_fn(A) +
      • +
    • +A and B must have the same matrix_type/cube_type +
      • +
    • +misc_fn(A) is one of: +
        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        + exp(A)  + +   + + base-e exponential, ex +
        + exp2(A)  + +   + + base-2 exponential, 2x +
        + exp10(A)  + +   + + base-10 exponential, 10x +
        + trunc_exp(A) + +   + + base-e exponential, + truncated to avoid infinity +
        + (only for elements with type float or double) +
        + log(A)  + +   + + natural log, loge x +
        + log2(A)  + +   + + base-2 log, log2 x +
        + log10(A)  + +   + + base-10 log, log10 x +
        + trunc_log(A) + +   + + natural log, + truncated to avoid ±infinity +
        + (only for elements with type float or double) +
        + pow(A, p)  + +   + + raise to the power of p, xp +
        + sqrt(A)  + +   + + square root, x½ +
        + square(A)  + +   + + square, x2 +
        + floor(A) + +   + + largest integral value that is not greater than the input value +
        + ceil(A) + +   + + smallest integral value that is not less than the input value +
        + + +
      +
      • + +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = exp(A);
+
      +
    +
    • +
+
+

+ + +trigonometric functions (cos, sin, tan, ...) +
    +
  • +Apply a trigonometric function to each element +
    • +
    +
  • +Usage: +
      +
    • +matrix_type Y = trig_fn(X) +
      • +
    • +cube_type Y = trig_fn(X) +
      • +
    • +X and Y must have the same matrix_type/cube_type +
      • +
    • +trig_fn is one of: +
        +
      • +cos family: cos, acos, cosh, acosh +
        • +
      • +sin family: sin, asin, sinh, asinh +
        • +
      • +tan family: tan, atan, tanh, atanh +
        • +
      +
      • + +
    +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+mat Y = cos(X);
+
      +
    +
    • +
+
+
+ +
+
+
+Scalar Valued Functions of Vectors/Matrices/Cubes +
+
+
+
+ + +accu(mat) +
accu(cube) +
    +
  • +Accumulate (sum) all elements +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+double x = accu(A);
+
+mat B = randu<mat>(5,5);
+double y = accu(A % B);
+
+// operator % performs element-wise multiplication,
+// hence accu(A % B) is a "multiply-and-accumulate"
+// operation
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +as_scalar(expression) +
    +
  • +Evaluate an expression that results in a 1x1 matrix, +followed by converting the 1x1 matrix to a pure scalar +
    • +
    +
  • +If a binary or trinary expression is given (ie. 2 or 3 terms), +the function will try to exploit the fact that the result is a 1x1 matrix +by using optimised expression evaluations +
    • +
    +
  • +Examples: +
      +
      +rowvec r = randu<rowvec>(5);
+colvec q = randu<colvec>(5);
+mat    X = randu<mat>(5,5);
+
+// examples of some expressions
+// for which optimised implementations exist
+
+double a = as_scalar(r*q);
+double b = as_scalar(r*X*q);
+double c = as_scalar(r*diagmat(X)*q);
+double d = as_scalar(r*inv(diagmat(X))*q);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +det(A, slow = false) +
    +
  • +Determinant of square matrix A +
    • +
    +
  • +If A is not square, a std::logic_error exception is thrown +
    • +
    +
  • +Caveat: for large matrices you may want to use log_det() instead +
    • +
    +
  • +For matrix sizes ≤ 4x4, a fast algorithm is used by default. +In rare instances, the fast algorithm might be less precise than the standard algorithm. +To force the use of the standard algorithm, set the slow argument to true +
    • +
    +
  • +Examples: +
      +
      +mat    A = randu<mat>(5,5);
+double x = det(A);
+
+mat44  B = randu<mat>(4,4);
+
+double y = det(B);       // use fast algorithm by default
+double z = det(B, true); // use slow algorithm
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +dot(A, B) +
cdot(A, B) +
norm_dot(A, B) +
    +
  • +dot(A,B): dot product of A and B, under the assumption that A and B are vectors with the same number of elements +
    • +
    +
  • +cdot(A,B): as per dot(A,B), but the complex conjugate of A is used +
    • +
    +
  • +norm_dot(A,B): normalised version of dot(A,B) +
    • +
    +
  • +Examples: +
      +
      +vec a = randu<vec>(10);
+vec b = randu<vec>(10);
+
+double x = dot(a,b);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +log_det(val, sign, A) +
    +
  • +Log determinant of square matrix A, such that the determinant is equal to exp(val)*sign +
    • +
    +
  • +If A is not square, a std::logic_error exception is thrown +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+double val;
+double sign;
+
+log_det(val, sign, A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +norm(X, p) + +
    +
  • +Compute the p-norm of X, where X can be a vector or a matrix +
    • +
    +
  • +For vectors, p is an integer ≥1, or one of: "-inf", "inf", "fro" +
    • +
    +
  • +For matrices, p is one of: 1, 2, "inf", "fro" +
    • +
    +
  • +"-inf" is the minimum norm, "inf" is the maximum norm, while "fro" is the Frobenius norm +
    • +
    +
  • +To obtain the zero norm or Hamming norm (ie. the number of non-zero elements), +you may want to use this expression: accu(X != 0). +
    • +
    +
  • +Examples: +
      +
      +vec    q = randu<vec>(5);
+double x = norm(q, 2);
+double y = norm(q, "inf");
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +rank(X, tolerance = default) + +
    +
  • Returns the rank of matrix X

    • +
  • Any singular values less than default tolerance are treated as zero

    • +
  • The default tolerance is max(X.n_rows, X.n_cols)*eps(sigma), +where sigma is the largest singular value of X +

    • +
  • The computation is based on singular value decomposition; +if the decomposition fails, a std::runtime_error exception is thrown

    • +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+uword r = rank(A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +trace(mat) +
    +
  • +Sum of the diagonal elements of a square matrix +
    • +
    +
  • +A std::logic_error exception is thrown if the given matrix is not square +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+double x = trace(A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+
+ +
+
+
+Scalar/Vector Valued Functions of Vectors/Matrices +
+
+
+
+ + +diagvec(A, k=0) +
    +
  • +Extract the k-th diagonal from matrix A +
    • +
    +
  • +The argument k is optional -- by default the main diagonal is extracted (k=0) +
    • +
    +
  • For k > 0, the k-th super-diagonal is extracted (top-right corner)
    • +
    +
  • For k < 0, the k-th sub-diagonal is extracted (bottom-left corner)
    • +
    +
  • +An extracted a diagonal is interpreted as a column vector +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+vec d = diagvec(A);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+
+
+ + +min(mat, dim=0) +
min(rowvec) +
min(colvec) +
+
max(mat, dim=0) +
max(rowvec) +
max(colvec) +
    +
  • +For a matrix argument, return the extremum value for each column (dim=0), or each row (dim=1) +
    • +
    +
  • +For a vector argument, return the extremum value +
    • +
    +
  • +Examples: +
      +
      +colvec q = randu<colvec>(10,1);
+double x = max(q);
+
+mat    A = randu<mat>(10,10);
+rowvec b = max(A);
+
+// same result as max(A)
+// the 0 explicitly indicates
+// "traverse across rows"
+rowvec c = max(A,0); 
+
+// the 1 explicitly indicates
+// "traverse across columns"
+colvec d = max(A,1);
+
+// find the overall maximum value
+double y = max(max(A));
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +prod(mat, dim=0) +
prod(rowvec) +
prod(colvec) +
    +
  • +For a matrix argument, return the product of elements in each column (dim=0), or each row (dim=1) +
    • +
    +
  • +For a vector argument, return the product of all elements +
    • +
    +
  • +Examples: +
      +
      +colvec q = randu<colvec>(10,1);
+double x = prod(q);
+
+mat    A = randu<mat>(10,10);
+rowvec b = prod(A);
+
+// same result as prod(A)
+// the 0 explicitly indicates
+// "traverse across rows"
+rowvec c = prod(A,0);
+
+// the 1 explicitly indicates
+// "traverse across columns"
+colvec d = prod(A,1);
+
+// find the overall product
+double y = prod(prod(A));
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + + +sum(mat, dim=0) +
sum(rowvec) +
sum(colvec) +
    +
  • +For a matrix argument, return the sum of elements in each column (dim=0), or each row (dim=1) +
    • +
    +
  • +For a vector argument, return the sum of all elements +
    • +
    +
  • +To get a sum of all the elements regardless of the argument type (ie. matrix or vector), +you may wish to use accu() instead +
    • +
    +
  • +Examples: +
      +
      +colvec q = randu<colvec>(10,1);
+double x = sum(q);
+
+mat    A = randu<mat>(10,10);
+rowvec b = sum(A);
+
+// same result as sum(A)
+// the 0 explicitly indicates
+// "traverse across rows"
+rowvec c = sum(A,0);
+
+// the 1 explicitly indicates
+// "traverse across columns"
+colvec d = sum(A,1);
+
+// find the overall sum
+double y = sum(sum(A));
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +statistics: mean, median, stddev, var + +
    + + + + + + + + + + + + + + + + + + + + + + + +
    + mean(mat, dim=0) +
    mean(colvec) +
    mean(rowvec) +
    +
    +     		+   + + mean (average value) +
    + median(mat, dim=0) +
    median(colvec) +
    median(rowvec) +
    +
    +     		+   + + median +
    + stddev(mat, norm_type=0, dim=0) +
    stddev(colvec, norm_type=0) +
    stddev(rowvec, norm_type=0) +
    +
    +     		+   + + standard deviation +
    + var(mat, norm_type=0, dim=0) +
    var(colvec, norm_type=0) +
    var(rowvec, norm_type=0) +
    +
    +     		+   + + variance +
    +
    +
  • +For a matrix argument, find a particular statistic for each column (dim=0), or each row (dim=1) +
    • +
    +
  • +For a vector argument, return a particular statistic calculated using all the elements of the vector +
    • +
    +
  • +For the var() and stddev() functions, the default norm_type=0 performs normalisation using N-1 (where N is the number of samples), +providing the best unbiased estimator. +Using norm_type=1 causes normalisation to be done using N, which provides the second moment around the mean +
    • +
    +
  • +Examples: +
      +
      +mat A    = randu<mat>(5,5);
+mat B    = mean(A);
+mat C    = var(A);
+double m = mean(mean(A));
+
+vec    q = randu<vec>(5);
+double v = var(q);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+
+ +
+
+
+Vector/Matrix/Cube Valued Functions of Vectors/Matrices/Cubes +
+
+
+
+ + + +C = conv(A, B) + +
    +
  • +Convolution of vectors A and B. +
    • +
    +
  • +If A and B are polynomial coefficient vectors, convolving them is equivalent to multiplying the two polynomials +
    • +
    +
  • +The convolution operation is also equivalent to FIR filtering +
    • +
    +
  • +The orientation of the result vector is the same as the orientation of A (ie. column or row vector) +
    • +
    +
  • +Examples: +
      +
      +vec A = randu<vec>(128) - 0.5;
+vec B = randu<vec>(128) - 0.5;
+
+vec C = conv(A,B);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + + +conv_to<type>::from(X) + +
    +
  • +A form of casting +
    • +
    +
  • +Convert between matrix/vector types (eg. mat to fmat), as well as cube types (eg. cube to fcube) +
    • +
    +
  • +Conversion between std::vector and Armadillo matrices/vectors is also possible +
    • +
    +
  • +Conversion of a mat object into colvec, rowvec or std::vector is possible if the object can be interpreted as a vector +
    • +
    +
  • +Examples: +
      +
      +mat  A = randu<mat>(5,5);
+fmat B = conv_to<fmat>::from(A);
+
+typedef std::vector<double> stdvec;
+
+stdvec x(3);
+x[0] = 0.0; x[1] = 1.0;  x[2] = 2.0;
+
+colvec y = conv_to< colvec >::from(x);
+stdvec z = conv_to< stdvec >::from(y); 
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +conj(cx_mat) +
conj(cx_cube) +
    +
  • +Obtain the complex conjugate of each element in a complex matrix/cube +
    • +
    +
  • +Examples: +
      +
      +cx_mat X = randu<cx_mat>(5,5);
+cx_mat Y = conj(X);
+
      +
    +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +cor(X, Y, norm_type=0) +
cor(X, norm_type=0) +
    +
  • +For two matrix arguments X and Y, +if each row of X and Y is an observation and each column is a variable, +the (i,j)-th entry of cor(X,Y) is the correlation coefficient between the i-th variable in X and the j-th variable in Y +
    • +
    +
  • +For vector arguments, the type of vector is ignored and each element in the vector is treated as an observation +
    • +
    +
  • +For matrices, X and Y must have the same dimensions +
    • +
    +
  • +For vectors, X and Y must have the same number of elements +
    • +
    +
  • +cor(X) is equivalent to cor(X, X), also called autocorrelation +
    • +
    +
  • +The default norm_type=0 performs normalisation of the correlation matrix using N-1 (where N is the number of observations). +Using norm_type=1 causes normalisation to be done using N +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(4,5);
+mat Y = randu<mat>(4,5);
+
+mat R = cor(X,Y);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +cov(X, Y, norm_type=0) +
cov(X, norm_type=0) +
    +
  • +For two matrix arguments X and Y, +if each row of X and Y is an observation and each column is a variable, +the (i,j)-th entry of cov(X,Y) is the covariance between the i-th variable in X and the j-th variable in Y +
    • +
    +
  • +For vector arguments, the type of vector is ignored and each element in the vector is treated as an observation +
    • +
    +
  • +For matrices, X and Y must have the same dimensions +
    • +
    +
  • +For vectors, X and Y must have the same number of elements +
    • +
    +
  • +cov(X) is equivalent to cov(X, X) +
    • +
    +
  • +The default norm_type=0 performs normalisation using N-1 (where N is the number of observations), +providing the best unbiased estimation of the covariance matrix (if the observations are from a normal distribution). +Using norm_type=1 causes normalisation to be done using N, which provides the second moment matrix of the observations about their mean +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(4,5);
+mat Y = randu<mat>(4,5);
+
+mat C = cov(X,Y);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +cross(A, B) +
    +
  • +Calculate the cross product between A and B, under the assumption that A and B are 3 dimensional vectors +
    • +
    +
  • +Examples: +
      +
      +vec a = randu<vec>(3);
+vec b = randu<vec>(3);
+
+vec c = cross(a,b);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +cumsum(mat, dim=0) +
cumsum(rowvec) +
cumsum(colvec) +
    +
  • +For a matrix argument, return a matrix containing the cumulative sum of elements in each column (dim=0, the default), or each row (dim=1) +
    • +
    +
  • +For a vector argument, return a vector of the same orientation, containing the cumulative sum of elements +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = cumsum(A);
+
+vec x = randu<vec>(10);
+vec y = cumsum(x);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +diagmat(mat) +
diagmat(rowvec) +
diagmat(colvec) +
    +
  • +Interpret a matrix or vector as a diagonal matrix +
    • +
    +
  • +For mat, given matrix must be square; the main diagonal is copied and all other elements in the generated matrix are set to zero +
    • +
    +
  • +For colvec and rowvec, elements of the vector are placed on the main diagonal in the generated matrix and all other elements are set to zero +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = diagmat(A);
+mat C = A*diagmat(A);
+
+rowvec q = randu<rowvec>(5);
+colvec r = randu<colvec>(5);
+mat    X = diagmat(q)*diagmat(r);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+
+
+ + +find(X, k=0, s="first") +
    +
  • Return a column vector of the indices of non-zero elements of X
    • +
    +
  • The output vector must have the type uvec or umat +(ie. the indices are stored as unsigned integers of type uword) +
    • +
    +
  • +The input matrix X is interpreted as a vector, with column-by-column ordering of the elements of X +
    • +
    +
  • Relational operators can be used instead of X, eg. A > 0.5 +
    • +
    +
  • If k=0 (default), return the indices of all non-zero elements, otherwise return at most k of their indices
    • +
    +
  • If s="first" (default), return at most the first k indices of the non-zero elements +
    • +
    +
  • If s="last", return at most the last k indices of the non-zero elements +
    • +
    +
  • +Examples: +
      +
      +mat  A  = randu<mat>(5,5);
+mat  B  = randu<mat>(5,5);
+
+uvec q1 = find(A > B);
+uvec q2 = find(A > 0.5);
+uvec q3 = find(A > 0.5, 3, "last");
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+
+
+ + +fliplr(mat) +
flipud(mat) +
    +
  • +fliplr(): generate a copy of the input matrix, with the order of the columns reversed +
    • +
    +
  • +flipud(): generate a copy of the input matrix, with the order of the rows reversed +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+mat B = fliplr(A);
+mat C = flipud(A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +imag(cx_mat) +
imag(cx_cube) +
+
real(cx_mat) +
real(cx_cube) +
    +
  • +Extract the imaginary/real part of a complex matrix/cube +
    • +
    +
  • +Examples: +
      +
      +cx_mat C = randu<cx_mat>(5,5);
+
+mat    A = imag(C);
+mat    B = real(C);
+
      +
    +
    • +
    +
  • Caveat: versions 4.4, 4.5 and 4.6 of the GCC C++ compiler have a bug when using the -std=c++0x compiler option (ie. experimental support for C++11); +to work around this bug, preface Armadillo's imag() and real() with the arma namespace qualification, eg. arma::imag(C) +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +join_rows(mat A, mat B) +
join_cols(mat A, mat B) +
join_slices(cube A, cube B) +
    +
  • +join_rows(): +for two matrices A and B, append each row of B to its respective row of A; +matrices A and B must have the same number of rows +
    • +
    +
  • +join_cols(): +for two matrices A and B, append each column of B to its respective column of A; +matrices A and B must have the same number of columns +
    • +
    +
  • +join_slices(): +for two cubes A and B, append the slices of B to the slices of A; +cubes A and B have the same number of rows and columns (ie. all slices must have the same size) +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+mat B = randu<mat>(4,6);
+mat C = randu<mat>(6,5);
+
+mat X = join_rows(A,B);
+mat Y = join_cols(A,C);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +kron(A,B) + +
    +
  • Kronecker tensor product.
    • +
    +
  • Using matrix A (with n rows and p columns) and matrix B (with m rows and q columns), +kron(A,B) returns a matrix (with nm rows and pq columns) which denotes the tensor product of A and B +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+mat B = randu<mat>(5,4);
+
+mat K = kron(A,B);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +reshape(mat, n_rows, n_cols, dim=0) +
reshape(cube, n_rows, n_cols, n_slices, dim=0) +
    +
  • +Generate a matrix/cube sized according to given size specifications, +whose elements are taken from the given matrix/cube, either column-wise (dim=0) or row-wise (dim=1); +the elements in the generated object are placed column-wise (ie. the first column is filled up before filling the second column) +
    • +
    +
  • +The layout of the elements in the generated object will be different to the layout in the given object +
    • +
    +
  • +This function can be used to create a vector representation of a matrix (ie. concatenate all the columns or rows) +
    • +
    +
  • +The total number of elements in the generated matrix/cube doesn't have to be the same as the total number of elements in the given matrix/cube +
    • +
    +
  • +If the total number of elements in the given matrix/cube is less than the specified size, +the remaining elements in the generated matrix/cube are set to zero +
    • +
    +
  • +If the total number of elements in the given matrix/cube is greater than the specified size, +only a subset of elements is taken from the given matrix/cube +
    • +
    +
  • +Caveat: +reshape() is slower than .set_size(), which doesn't preserve data +
    • +
    +
  • +Caveat: +if you wish to grow/shrink a matrix while preserving the elements as well as the layout of the elements, +use resize() instead +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(10, 5);
+mat B = reshape(A, 5, 10);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +resize(mat, n_rows, n_cols) +
resize(cube, n_rows, n_cols, n_slices) +
    +
  • +Generate a matrix/cube sized according to given size specifications, +whose elements as well as the layout of the elements are taken from the given matrix/cube +
    • +
    +
  • +Caveat: +resize() is slower than .set_size(), which doesn't preserve data +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4, 5);
+mat B = resize(A, 7, 6);
+
      +
    +
    • +
    +
  • +This function was added in version 2.4.1 +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +shuffle(mat, dim=0) +
shuffle(rowvec, dim=0) +
shuffle(colvec, dim=0) +
    +
  • +Shuffle the rows (dim=0) or columns (dim=1) of a matrix or vector +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+mat B = shuffle(A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +sort(mat, sort_type=0, dim=0) +
sort(rowvec, sort_type=0) +
sort(colvec, sort_type=0) +
    +
  • For a matrix argument, return a matrix with the elements of the input matrix sorted in each column (dim=0), or each row (dim=1)
    • +
    +
  • sort_type=0 (default) indicates an ascending sort
    • +
    +
  • sort_type=1 indicates a descending sort
    • +
    +
  • For a vector argument, return a vector which is a sorted version of the input vector
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(10,10);
+mat B = sort(A);
+
      +
    +
    • +
  • +See also: + +
    • +
    +
+

+ + +sort_index(colvec, sort_type=0) +
sort_index(rowvec, sort_type=0) +
    +
  • Return a vector which describes the sorted order of the given vector's elements +(ie. it contains the indices of the given vector's elements) +
    • +
    +
  • The output vector must have the type uvec or umat +(ie. the indices are stored as unsigned integers of type uword) +
    • +
    +
  • sort_type=0 (default) indicates an ascending sort
    • +
    +
  • sort_type=1 indicates a descending sort
    • +
    +
  • +Examples: +
      +
      +vec  q       = randu<vec>(10);
+uvec indices = sort_index(q);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +symmatu(A) +
symmatl(A) +
    +
  • +symmatu(A): interpret square matrix A as symmetric, reflecting the upper triangle to the lower triangle +
    • +
    +
  • +symmatl(A): interpret square matrix A as symmetric, reflecting the lower triangle to the upper triangle +
    • +
    +
  • +If A is non-square, a std::logic_error exception is thrown +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+mat B = symmatu(A);
+mat C = symmatl(A);
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + +strans(mat) +
strans(colvec) +
strans(rowvec) +
    +
  • +Simple matrix transpose, without taking the conjugate of the elements (complex matrices) +
    • +
    +
  • +Use trans() instead, unless you explicitly need to take the transpose of a complex matrix without taking the conjugate of the elements +
    • +
    +
  • See also: + +
    • +
+
+

+ + + +trans(mat) +
trans(colvec) +
trans(rowvec) +
    +
  • +Matrix transpose / Hermitian transpose +
    • +
    +
  • +If a given object has real elements, a normal transpose is done +
    • +
    +
  • +If a given object has complex elements, a Hermitian transpose is done (ie. the conjugate of the elements is taken during the transpose operation) +
    • +
    +
  • +Caveat: for complex matrices, the functionality of trans() has changed in version 2.0: +
      +
    • in version 1.2.x and earlier, trans() does not take the conjugate of complex elements
      • +
    • in version 1.2.x and earlier, the deprecated htrans() function is used for the Hermitian transpose
      • +
    +
    • +
    +
  • +Examples: +
      +
      mat A = randu<mat>(5,10);
+mat B = trans(A);
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+

+ + + +trimatu(A) +
trimatl(A) +
    +
  • +trimatu(A): interpret square matrix A as upper triangular +
    • +
    +
  • +trimatl(A): interpret square matrix A as lower triangular +
    • +
    +
  • +A std::logic_error exception is thrown if A is non-square +
    • +
    +
  • +Examples: +
      +
      mat A = randu<mat>(5,5);
+mat U = trimatu(A);
+mat L = trimatl(A);
+
+// tell the inv() function to look only
+// at the upper triangular part
+mat X = inv( trimatu(U) );
+
      +
    +
    • +
    +
  • See also: + +
    • +
+
+
+ + +
+
+
+Decompositions, Inverses and Equation Solvers +
+
+
+
+ + +R = chol(X) +
chol(R, X) +
    +
  • +Cholesky decomposition of X, such that trans(R)*R = X +
    • +
    +
  • +X must be a symmetric, positive-definite matrix +
    • +
    +
  • If the decomposition fails, R is reset and: +
      +
    • chol(X) throws a std::runtime_error exception
      • +
    • chol(R,X) returns a bool set to false
      • +
    +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+mat Y = trans(X)*X;
+
+mat R = chol(Y);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +vec eigval = eig_sym(mat X) +
vec eigval = eig_sym(cx_mat X) +
+
eig_sym(vec eigval, mat X) +
eig_sym(vec eigval, cx_mat X) +
+
eig_sym(vec eigval, mat eigvec, mat X) +
eig_sym(vec eigval, cx_mat eigvec, cx_mat X) +
    +
  • +Eigen decomposition of symmetric/hermitian matrix X
    • +
    +
  • The eigenvalues and corresponding eigenvectors are stored in eigval and eigvec, respectively
    • +
    +
  • +The eigenvalues are in ascending order +
    • +
    +
  • If X is not square, a std::logic_error exception is thrown
    • +
    +
  • If the decomposition fails, the output objects are reset and: +
      +
    • eig_sym(X) throws a std::runtime_error exception
      • +
    • eig_sym(eigval, X) and eig_sym(eigval, eigvec, X) return a bool set to false
      • +
    +
    • +
    +
  • There is currently no check whether X is symmetric
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(10,10);
+mat B = trans(A)*A;  // generate a symmetric matrix
+
+vec eigval;
+mat eigvec;
+
+eig_sym(eigval, eigvec, B);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +eig_gen(cx_vec eigval, cx_mat eigvec, mat X, side='r') +
+eig_gen(cx_vec eigval, cx_mat eigvec, cx_mat X, side='r') +
+
+eig_gen(cx_vec eigval, mat l_eigvec, mat r_eigvec, mat X) +
+eig_gen(cx_vec eigval, cx_mat l_eigvec, cx_mat r_eigvec, cx_mat X) +
    +
  • +Eigen decomposition of general (non-symmetric/non-hermitian) square matrix X
    • +
    +
  • The eigenvalues and corresponding eigenvectors are stored in eigval and eigvec, respectively
    • +
    +
  • +For the first two forms, side='r' (default) specifies that right eigenvectors are computed, +while side='l' specifies that left eigenvectors are computed +
    • +
    +
  • For the last two forms, both left and right eigenvectors are computed
    • +
    +
  • +The eigenvalues are not guaranteed to be ordered +
    • +
    +
  • If X is not square, a std::logic_error exception is thrown
    • +
    +
  • If the decomposition fails, the output objects are reset and eig_gen() returns a bool set to false
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(10,10);
+
+cx_vec eigval;
+cx_mat eigvec;
+
+eig_gen(eigval, eigvec, A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +B = inv(A, slow = false) +
+inv(B, A, slow = false) +
    +
  • +Inverse of square matrix A +
    • +
    +
  • +If A is known to be a triangular matrix, +the inverse can be computed faster by explicitly marking the matrix as triangular +through trimatu() or trimatl() +
    • +
    +
  • +If A is known to be a positive-definite symmetric matrix, +the inverse can be computed faster by explicitly marking the matrix using sympd() +
    • +
    +
  • +If A is not square, a std::logic_error exception is thrown +
    • +
    +
  • If A appears to be singular, B is reset and: +
      +
    • inv(A) throws a std::runtime_error exception
      • +
    • inv(B,A) returns a bool set to false
      • +
    +
    • +
    +
  • +If you want to solve a system of linear equations, eg., X = inv(A)*B, +the solve() function is generally more efficient +
    • +
    +
  • +For matrix sizes ≤ 4x4, a fast inverse algorithm is used by default. +In rare instances, the fast algorithm might be less precise than the standard algorithm. +To force the use of the standard algorithm, set the slow argument to true +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = inv(A);
+
+
+// Diagonal elements in C are set to the
+// reciprocal of the corresponding elements in A.
+// Off-diagonal elements in C are set to zero.
+mat C = inv( diagmat(A) );
+
+
+// tell inv() to look only at the upper triangular part of A
+mat D = inv( trimatu(A) );
+
+
+// tell inv() that AA is a symmetric positive definite matrix
+mat AA = A*trans(A);
+mat E  = inv( sympd(AA) );
+
+
+mat44 F = randu<mat>(4,4);
+
+mat G = inv(F);       // use fast algorithm by default
+mat H = inv(F, true); // use slow algorithm
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + + + +lu(mat L, mat U, mat P, mat X) +
+lu(mat L, mat U, mat X) +
    +
  • +Lower-upper decomposition (with partial pivoting) of matrix X +
    • +
    +
  • +The first form provides +a lower-triangular matrix L, +an upper-triangular matrix U, +and a permutation matrix P, +such that trans(P)*L*U = X +
    • +
    +
  • +The second form provides permuted L and U, such that L*U = X. +Note that in this case L is generally not lower-triangular +
    • +
    +
  • +If the decomposition fails, the output objects are reset and lu() returns a bool set to false +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+
+mat L, U, P;
+
+lu(L, U, P, A);
+
+mat B = trans(P)*L*U;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +B = pinv(A, tolerance = default) +
pinv(B, A, tolerance = default) +
    +
  • Moore-Penrose pseudo-inverse of matrix A
    • +
    +
  • The computation is based on singular value decomposition; +if the decomposition fails, B is reset and: +
      +
    • pinv(A) throws a std::runtime_error exception
      • +
    • pinv(B,A) returns a bool set to false
      • +
    +
    +
  • Any singular values less than tol are treated as zero
    • +
    +
  • For matrix A with m rows and n columns, +the default tolerance is max(m,n)*norm(A)*math::eps(), +where math::eps() denotes the difference between 1 and the least value greater than 1 that is representable
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(4,5);
+mat B = pinv(A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +mat coeff = princomp(mat X) +
cx_mat coeff = princomp(cx_mat X)
+ +
princomp(mat coeff, mat X) +
princomp(cx_mat coeff, cx_mat X)
+ +
princomp(mat coeff, mat score, mat X) +
princomp(cx_mat coeff, cx_mat score, cx_mat X)
+ +
princomp(mat coeff, mat score, vec latent, mat X) +
princomp(cx_mat coeff, cx_mat score, vec latent, cx_mat X)
+ +
princomp(mat coeff, mat score, vec latent, vec tsquared, mat X) +
princomp(cx_mat coeff, cx_mat score, vec latent, cx_vec tsquared, cx_mat X)
+
+
    +
  • Principal component analysis of matrix X

    • +
  • Each row of X is an observation and each column is a variable

    • +
  • output objects: +
      +
    • coeff: principal component coefficients
      • +
    • score: projected data
      • +
    • latent: eigenvalues of the covariance matrix of X
      • +
    • tsquared: Hotteling's statistic for each sample
      • +
    +
    • +
    +
  • The computation is based on singular value decomposition; +if the decomposition fails, the output objects are reset and: +
      +
    • princomp(X) throws a std::runtime_error exception
      • +
    • remaining forms of princomp() return a bool set to false
      • +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,4);
+
+mat coeff;
+mat score;
+vec latent;
+vec tsquared;
+
+princomp(coeff, score, latent, tsquared, A);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +qr(Q,R,X) +
    +
  • +Decomposition of matrix X into an orthogonal (Q) and a right triangular matrix (R), such that Q*R = X +
    • +
    +
  • +If the decomposition fails, Q and R are reset and the function returns a bool set to false +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+mat Q, R;
+
+qr(Q,R,X);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +X = solve(A, B, slow = false) +
solve(X, A, B, slow = false) +
    +
  • Solve a system of linear equations, ie., A*X = B, where X is unknown
    • +
    +
  • For a square matrix A, this function is conceptually the same as X = inv(A)*B, but is more efficient
    • +
    +
  • Similar functionality to the "\" (left division operator) operator in Matlab/Octave, ie. X = A \ B
    • +
    +
  • The number of rows in A and B must be the same
    • +
    +
  • +If A is known to be a triangular matrix, +the solution can be computed faster by explicitly marking the matrix as triangular +through trimatu() or trimatl() +
    • +
    +
  • +If A is non-square (and hence also non-triangular), +solve() will also try to provide approximate solutions to under-determined as well as over-determined systems
    • +
    +
  • +If no solution is found, X is reset and: +
      +
    • solve(A,B) throws a std::runtime_error exception
      • +
    • solve(X,A,B) returns a bool set to false
      • +
    +
    • +
    +
  • +For matrix sizes ≤ 4x4, a fast algorithm is used by default. +In rare instances, the fast algorithm might be less precise than the standard algorithm. +To force the use of the standard algorithm, set the slow argument to true +
    • +
    +
  • +NOTE: Old versions of the ATLAS library (eg. 3.6) can corrupt memory and crash your program; +the standard LAPACK library and later versions of ATLAS (eg. 3.8) work without problems +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+vec b = randu<vec>(5);
+mat B = randu<mat>(5,5);
+
+vec x = solve(A, b);
+mat X = solve(A, B);
+
+vec x2;
+solve(x2, A, b);
+
+// tell solve() to look only at the upper triangular part of A
+mat Y = solve( trimatu(A), B );
+
+
+mat44 C = randu<mat>(4,4);
+mat44 D = randu<mat>(4,4);
+
+mat E = solve(C, D);       // use fast algorithm by default
+mat F = solve(C, D, true); // use slow algorithm
+
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + + +vec s = svd(mat X) +
vec s = svd(cx_mat X) +
+
svd(vec s, mat X), +
svd(vec s, cx_mat X) +
+
svd(mat U, vec s, mat V, mat X) +
svd(cx_mat U, vec s, cx_mat V, cx_mat X) +
    +
  • +The single and two argument versions compute the singular values of X +
    • +
    +
  • +The four argument version computes the full singular value decomposition of X +
    • +
    +
  • If X is square, it can be reconstructed using X = U*diagmat(s)*trans(V) +
    • +
    +
  • +The singular values are in descending order +
    • +
    +
  • +If the decomposition fails, the output objects are reset and: +
      +
    • svd(X) throws a std::runtime_error exception
      • +
    • svd(s,X) and svd(U,s,V,X) return a bool set to false
      • +
    +
    • +
    +
  • +NOTE: Old versions of the ATLAS library (eg. 3.6) can corrupt memory and crash your program; +the standard LAPACK library and later versions of ATLAS (eg. 3.8) work without problems +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(5,5);
+
+mat U;
+vec s;
+mat V;
+svd(U,s,V,X);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+
+
+ + +svd_econ(mat U, vec s, mat V, mat X, mode = 'b') +
svd_econ(cx_mat U, vec s, cx_mat V, cx_mat X, mode = 'b') +
    +
  • +Economical singular value decomposition of X +
    • +
    +
  • +mode is one of: +
      +
    • 'l': compute only left singular vectors
      • +
    • 'r': compute only right singular vectors
      • +
    • 'b': compute both left and right singular vectors (default)
      • +
    +
    • +
    +
  • +The singular values are in descending order +
    • +
    +
  • +If the decomposition fails, the output objects are reset and bool set to false is returned +
    • +
    +
  • +Examples: +
      +
      +mat X = randu<mat>(4,5);
+
+mat U;
+vec s;
+mat V;
+svd_econ(U, s, V, X, 'l');
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+
+
+ + +X = syl(A, B, C) +
syl(X, A, B, C) +
    +
  • Solve the Sylvester equation, ie., AX + XB + C = 0, where X is unknown.
    • +
    +
  • Matrices A, B and C must be square sized.
    • +
    +
  • +If no solution is found, X is reset and: +
      +
    • syl(A,B,C) throws a std::runtime_error exception
      • +
    • svd(X,A,B,C) returns a bool set to false
      • +
    +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = randu<mat>(5,5);
+mat C = randu<mat>(5,5);
+
+mat X1 = syl(A, B, C);
+
+mat X2;
+syl(X2, A, B, C);
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+
+ + +
+
+
+Miscellaneous +
+
+
+
+ + +is_finite(X) +
    +
  • +Returns true if all elements in X are finite +
    • +
    +
  • +Returns false if at least one element in X is non-finite (±infinity or NaN) +
    • +
    +
  • +X can be a scalar (eg. double), vector, matrix or cube +
    • +
    +
  • +Examples: +
      +
      +mat A = randu<mat>(5,5);
+mat B = randu<mat>(5,5);
+
+B(1,1) = math::nan();
+
+cout << is_finite(A) << endl;
+cout << is_finite(B) << endl;
+
+cout << is_finite( 0.123456789 ) << endl;
+cout << is_finite( math::nan() ) << endl;
+cout << is_finite( math::inf() ) << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
    +
+

+ + +logging of warnings and errors +
+
+set_stream_err1(user_stream)
+set_stream_err2(user_stream)
+
+std::ostream& x = get_stream_err1() +
+std::ostream& x = get_stream_err2() +
+
    +
  • +By default, Armadillo prints warnings and messages associated with std::logic_error and std::runtime_error exceptions to the std::cout stream +
    • +
    +
  • set_stream_err1(): change the stream for messages associated with std::logic_error exceptions (eg. out of bounds accesses)
    • +
    +
  • set_stream_err2(): change the stream for warnings and messages associated with std::runtime_error exceptions (eg. failed decompositions)
    • +
    +
  • get_stream_err1(): get a reference to the stream for messages associated with std::logic_error exceptions
    • +
    +
  • get_stream_err2(): get a reference to the stream for warnings and messages associated with std::runtime_error exceptions
    • +
    +
  • +Examples: +
      +
      +// print "hello" to the current err1 stream
+get_stream_err1() << "hello" << endl;
+
+// change the err2 stream to be a file
+ofstream f("my_log.txt");
+set_stream_err2(f);
+
+// trying to invert a singular matrix
+// will print a message to the err2 stream
+// and throw an exception
+mat X = zeros<mat>(5,5);
+mat Y = inv(X);
+
+// disable messages being printed to the err2 stream
+std::ostream nullstream(0);
+set_stream_err2(nullstream);
+
      +
    +
    • +
    +
  • +Caveat: set_stream_err1() and set_stream_err2() will not change the stream used by .print() +
    • +
    +
  • +See also: + +
    • +
    +
+
+ + + + +math constants (pi, e, euler, gratio, sqrt2, eps, log_min, log_max, nan, inf) +
+
    +
  • +Collection of constants, with their precision and/or value dependant on the numerical type and/or machine used. +
    • +
    +
  • +The constants are stored as static functions in the Math<type> class, +where type is either float or double. +
    • +
    +
  • +For convenience, Math<float> has been typedefed as fmath, +while Math<double> has been typedefed as math. +
    • +
    +
  • +Meaning of the constants: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + math::pi() + +   + + π, the ratio of any circle's circumference to its diameter +
      + math::e() + +   + + base of the natural logarithm +
      + math::euler() + +   + + Euler's constant, aka Euler-Mascheroni constant +
      + math::gratio() + +   + + golden ratio +
      + math::sqrt2() + +   + + square root of 2 +
      + math::eps() + +   + + the difference between 1 and the least value greater than 1 that is representable +
      + math::log_min() + +   + + log of minimum non-zero value +
      + math::log_max() + +   + + log of maximum value +
      + math::nan() + +   + + “not a number” (NaN) +
      + math::inf() + +   + + infinity +
      +
    +
    • +
    +
  • +Caveat: +nan() is not equal to anything, even itself; +if you wish to check whether a given number x is finite, +use is_finite(x). +
    • +
    +
  • +Examples: +
      +
      +cout << "2.0 * pi = " << 2.0 * math::pi() << endl;
+
+cout << "log_max for floats = ";
+cout << fmath::log_max() << endl;
+
+cout << "log_max for doubles = ";
+cout << math::log_max() << endl;
+
      +
    +
    • +
  • +See also: + +
    • +
+
+

+ + +physical constants (speed of light, etc) +
+
    +
  • +Collection of fundamental physical constants, +mainly taken from +NIST +and some from +WolframAlpha +on 2009-06-23. +
    • +
    +
  • +Constants from NIST are in turn sourced from the 2006 CODATA values. +
    • +
    +
  • +The constants are stored as static functions in the Phy<type> class, +where type is either float or double. +
    • +
    +
  • +For convenience, Phy<float> has been typedefed as fphy, +while Phy<double> has been typedefed as phy. +
    • +
    +
  • +Meaning of the constants: +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      + phy::m_u() + +   + + atomic mass constant (in kg) +
      + phy::N_A() + +   + + Avogadro constant +
      + phy::k() + +   + + Boltzmann constant (in joules per kelvin) +
      + phy::k_evk() + +   + + Boltzmann constant (in eV/K) +
      + phy::a_0() + +   + + Bohr radius (in meters) +
      + phy::mu_B() + +   + + Bohr magneton +
      + phy::Z_0() + +   + + characteristic impedance of vacuum (in ohms) +
      + phy::G_0() + +   + + conductance quantum (in siemens) +
      + phy::k_e() + +   + + Coulomb's constant (in meters per farad) +
      + phy::eps_0() + +   + + electric constant (in farads per meter) +
      + phy::m_e() + +   + + electron mass (in kg) +
      + phy::eV() + +   + + electron volt (in joules) +
      + phy::e() + +   + + elementary charge (in coulombs) +
      + phy::F() + +   + + Faraday constant (in coulombs) +
      + phy::alpha() + +   + + fine-structure constant +
      + phy::alpha_inv() + +   + + inverse fine-structure constant +
      + phy::K_J() + +   + + Josephson constant +
      + phy::mu_0() + +   + + magnetic constant (in henries per meter) +
      + phy::phi_0() + +   + + magnetic flux quantum (in webers) +
      + phy::R() + +   + + molar gas constant (in joules per mole kelvin) +
      + phy::G() + +   + + Newtonian constant of gravitation (in newton square meters per kilogram squared) +
      + phy::h() + +   + + Planck constant (in joule seconds) +
      + phy::h_bar() + +   + + Planck constant over 2 pi, aka reduced Planck constant (in joule seconds) +
      + phy::m_p() + +   + + proton mass (in kg) +
      + phy::R_inf() + +   + + Rydberg constant (in reciprocal meters) +
      + phy::c_0() + +   + + speed of light in vacuum (in meters per second) +
      + phy::sigma() + +   + + Stefan-Boltzmann constant +
      + phy::R_k() + +   + + von Klitzing constant (in ohms) +
      + phy::b() + +   + + Wien wavelength displacement law constant +
      +
    +
    • +
    +
  • +Examples: +
      +
      +cout << "speed of light = " << phy::c_0() << endl;
+
      +
    +
    • +
    +
  • +See also: + +
    • +
+
+

+ + +log_add(log_a, log_b) +
    +
  • +Safe replacement for log(exp(log_a) + exp(log_b)) +
    • +
    +
  • +Usage: +
      +
    • +scalar_type log_c = log_add(log_a, log_b) +
      • +
    • +scalar_type is either float or double +
      • +
    • +log_a, log_b and log_c must have the same type +
      • +
    +
    • +
+
+

+ + +uword, sword +
    +
  • +uword is a typedef for an unsigned integer with a minimum width of 32 bits; if ARMA_64BIT_WORD is enabled, the minimum width is 64 bits +
    • +
    +
  • +sword is a typedef for a signed integer with a minimum width of 32 bits; if ARMA_64BIT_WORD is enabled, the minimum width is 64 bits +
    • +
    +
  • +ARMA_64BIT_WORD can be enabled via editing include/armadillo_bits/config.hpp +
    • +
    +
  • See also: + +
    • +
    +
+

+ + +cx_float, cx_double + + + +
+
+ +Examples of Matlab/Octave syntax and conceptually corresponding Armadillo syntax + +
+
+
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + Matlab/Octave + +   + + Armadillo + +   + + Notes +
    +   + +   + +   + +   + +   +
    + A(1, 1) + +   + + A(0, 0) + +   + + indexing in Armadillo starts at 0 +
    + A(k, k) + +   + + A(k-1, k-1) + +   + +   +
    +   + +   + +   + +   + +   +
    + size(A,1) + +   + + A.n_rows + +   + + read only +
    + size(A,2) + +   + + A.n_cols + +   + +   +
    + size(Q,3) + +   + + Q.n_slices + +   + + Q is a cube (3D array) +
    + numel(A) + +   + + A.n_elem + +   + +   +
    +   + +   + +   + +   + +   +
    + A(:, k) + +   + + A.col(k) + +   + +this is a conceptual example only; +exact conversion from Matlab/Octave to Armadillo syntax +will require taking into account that indexing starts at 0 +
    + A(k, :) + +   + + A.row(k) + +   + +   +
    + A(:, p:q) + +   + + A.cols(p, q) + +   + +   +
    + A(p:q, :) + +   + + A.rows(p, q) + +   + +   +
    +   + +   + +   + +   + +   +
    + A(p:q, r:s) + +   + + + A.submat(p, r, q, s) + + +   + + + A.submat(first_row, first_col, last_row, last_col) + +
    +   + +   + + + or + + +   + +   +
    +   + +   + + + A( span(p,q), span(r,s) ) + + +   + + + A( span(first_row, last_row), span(first_col, last_col) ) + +
    +   + +   + +   + +   + +   +
    + Q(:, :, k) + +   + + Q.slice(k) + +   + + Q is a cube (3D array) +
    + Q(:, :, t:u) + +   + + Q.slices(t, u) + +   + +   +
    +   + +   + +   + +   + +   +
    + Q(p:q, r:s, t:u) + +   + + + Q.subcube(p, r, t, q, s, u) + + +   + + + .subcube(first_row, first_col, first_slice, last_row, last_col, last_slice) + +
    +   + +   + + + or + + +   + +   +
    +   + +   + + + Q( span(p,q), span(r,s), span(t,u) ) + + +   + +   +
    +   + +   + +   + +   + +   +
    + A' + +   + + A.t() or trans(A) + +   + + matrix transpose / Hermitian transpose +
    + (for complex matrices, the conjugate of each element is taken) +
    + A.' + +   + + A.st() or strans(A) + +   + + simple matrix transpose +
    + (for complex matrices, the conjugate of each element is not taken) +
    +   + +   + +   + +   + +   +
    + A = zeros(size(A)) + +   + + A.zeros() + +   + +   +
    + A = ones(size(A)) + +   + + A.ones() + +   + +   +
    + A = zeros(k) + +   + + A = zeros<mat>(k,k) + +   + +   +
    + A = ones(k) + +   + + A = ones<mat>(k,k) + +   + +   +
    +   + +   + +   + +   + +   +
    + C = complex(A,B) + +   + + cx_mat C = cx_mat(A,B) + +   + +   +
    +   + +   + +   + +   + +   +
    + A .* B + +   + + A % B + +   + + element-wise multiplication +
    + A ./ B + +   + + A / B + +   + + element-wise division +
    + A \ B + +   + + solve(A,B) + +   + + conceptually similar to inv(A)*B, but more efficient +
    + A = A + 1; + +   + + A++ + +   + +   +
    + A = A - 1; + +   + + A-- + +   + +   +
    +   + +   + +   + +   + +   +
    + A = [ 1 2; 3 4; ] + +   + +A << 1 << 2 << endr
    +   << 3 << 4 << endr; +     		+   + + element initialisation, + with special element endr indicating end of row +
    +   + +   + +   + +   + +   +
    + X = [ A  B ] + +   + + X = join_rows(A,B) + +   + +   +
    + X = [ A; B ] + +   + + X = join_cols(A,B) + +   + +   +
    +   + +   + +   + +   + +   +
    + A + +   + + cout << A << endl; +
    or +
    A.print("A ="); +     		+   + +   +
    +   + +   + +   + +   + +   +
    + save -ascii 'A.dat' A + +   + + A.save("A.dat", raw_ascii); + +   + + Matlab/Octave matrices saved as ascii are readable by Armadillo (and vice-versa) +
    + load -ascii 'A.dat' + +   + + A.load("A.dat", raw_ascii); + +   + +   +
    +   + +   + +   + +   + +   +
    + S = { 'abc'; 'def' } + +   + + field<std::string> S(2); +
    S(0) = "abc"; +
    S(1) = "def"; +     		+   + + fields can store arbitrary objects, in a 1D or 2D layout +
    +
+
+ + +
+
+example program +
+
+
    +
  • +If you save the program below as example.cpp, +under Linux you can compile it using: +
    +g++ example.cpp -o example -O1 -larmadillo +
    • +
      +
      +#include <iostream>
+#include <armadillo>
+
+using namespace std;
+using namespace arma;
+
+int main(int argc, char** argv)
+  {
+  mat A = randu<mat>(4,5);
+  mat B = randu<mat>(4,5);
+  
+  cout << A*trans(B) << endl;
+  
+  return 0;
+  }
+
      +
    +
  • +You may also want to have a look at the example programs that come with the Armadillo archive. +
    • +
    +
  • +As Armadillo is a template library, we strongly recommended to have optimisation enabled when compiling programs +(eg. when compiling with GCC, use the -O1 or -O2 options). +
    • +
+
+ + + + + +
+
+API Changes, Additions and Deprecations +
+
+Armadillo's version number is X.Y.Z, where X is a major version, Y is a minor version, and Z is the patch level (indicating bug fixes). +
+
+Within each major version (eg. 2.x), minor versions with an even number (eg. 2.2) are backwards compatible with earlier even minor versions (eg. 2.0). +For example, code written for version 2.0 will work with version 2.2. +However, as each minor version may have more features (ie. API extensions) than earlier versions, +code written for version 2.2 doesn't necessarily work with 2.0. +
+
+An odd minor version number (eg. 2.3) indicates an experimental version. +Experimental versions are generally faster and have more functionality, +but their APIs have not been finalised yet. +
+
+In general, we don't like changes to existing APIs and prefer not to break any user software. +However, to allow evolution and help code maintenance, we reserve the right to change the APIs in future major versions of Armadillo, +while remaining backwards compatible wherever possible +(eg. 3.0 may have slightly different APIs than 2.x). +Also, in a rare instance the user API may need to be altered if a bug fix absolutely requires it. +
+
+
+ +Below is a list of deprecated functionality; this functionality will be removed in version 3.0: +
    +
  • +.print_trans() and .raw_print_trans() are deprecated; +
    instead, you can chain .t() and .print() to achieve a similar result: .t().print() +
      +
    • +
  • +support for tying writeable auxiliary (external) memory to fixed size matrices is deprecated; +
    instead, you can use standard matrices with writeable auxiliary memory, +or initialise fixed size matrices by copying the memory. +Using auxiliary memory with standard matrices is unaffected. +
      +
    • +
+
+
+Below is a list of additions and changes since prior versions of Armadillo: +
    + +
  • Added in 2.4: +
      +
    • shorter forms of transposes: .t() and .st()
      • +
    • .resize() and resize() (added in 2.4.1)
      • +
    • optional use of 64 bit indices (allowing matrices to have more than 4 billion elements), +
      enabled via ARMA_64BIT_WORD in include/armadillo_bits/config.hpp
      • +
    • experimental support for C++11 initialiser lists, enabled via ARMA_USE_CXX11 in include/armadillo_bits/config.hpp
      • +
    +
    +
  • Changed in 2.4: +
      +
    • refactored code to eliminate warnings when using the Clang C++ compiler
      • +
    • umat, uvec, .min() and .max() +have been changed to use the uword type instead of the u32 type; +by default the uword and u32 types are equivalent (ie. unsigned integer type with a minimum width 32 bits); +however, when the use of 64 bit indices is enabled via ARMA_64BIT_WORD in include/armadillo_bits/config.hpp, +the uword type then has a minimum width of 64 bits +
    +
    • +
    +
  • Added in 2.2: + +
    +
  • Changed in 2.0: + +
    +
  • Added in 2.0: + +
    +
  • Added in 1.2: +
      +
    • .min() & .max() member functions of Mat and Cube
      • +
    • floor() and ceil()
      • +
    • representation of “not a number”: math::nan()
      • +
    • representation of infinity: math::inf()
      • +
    • standalone is_finite()
      • +
    • .in_range() can use span() arguments
      • +
    • fixed size matrices and vectors can use auxiliary (external) memory
      • +
    • submatrices and subfields can be accessed via X( span(a,b), span(c,d) )
      • +
    • subcubes can be accessed via X( span(a,b), span(c,d), span(e,f) )
      • +
    • the two argument version of span can be replaced by +span::all or span(), to indicate an entire range +
      • +
    • for cubes, the two argument version of span can be replaced by +a single argument version, span(a), to indicate a single column, row or slice +
      • +
    • arbitrary "flat" subcubes can be interpreted as matrices; for example: +
        +
        +cube Q = randu<cube>(5,3,4);
+mat  A = Q( span(1), span(1,2), span::all );
+// A has a size of 2x4
+
+vec v = ones<vec>(4);
+Q( span(1), span(1), span::all ) = v;
+
        +
      +
      • +
    • interpretation of matrices as triangular through trimatu() / trimatl()
      • +
    • explicit handling of triangular matrices by solve() and inv()
      • +
    • extended syntax for submatrices, including access to elements whose indices are specified in a vector
      • +
    • ability to change the stream used for logging of errors and warnings
      • +
    • ability to save/load matrices in raw binary format
      • +
    • cumulative sum function: cumsum()
      • +
    +
    • +
    +
  • +Changed in 1.0 (compared to earlier 0.x development versions): +
      +
    • +the 3 argument version of lu(), +eg. lu(L,U,X), +provides L and U which should be the same as produced by Octave 3.2 +(this was not the case in versions prior to 0.9.90) +
      • +
      +
    • +rand() has been replaced by randu(); +this has been done to avoid confusion with std::rand(), +which generates random numbers in a different interval +
      • +
      +
    • +In versions earlier than 0.9.0, +some multiplication operations directly converted result matrices with a size of 1x1 into scalars. +This is no longer the case. +If you know the result of an expression will be a 1x1 matrix and wish to treat it as a pure scalar, +use the as_scalar() wrapping function +
      • +
      +
    • +Almost all functions have been placed in the delayed operations framework (for speed purposes). +This may affect code which assumed that the output of some functions was a pure matrix. +The solution is easy, as explained below. +
      +
      +In general, Armadillo queues operations before executing them. +As such, the direct output of an operation or function cannot be assumed to be a directly accessible matrix. +The queued operations are executed when the output needs to be stored in a matrix, +eg. mat B = trans(A) or mat B(trans(A)). +If you need to force the execution of the delayed operations, +place the operation or function inside the corresponding Mat constructor. +For example, if your code assumed that the output of some functions was a pure matrix, +eg. chol(m).diag(), change the code to mat(chol(m)).diag(). +Similarly, if you need to pass the result of an operation such as A+B to one of your own functions, +use my_function( mat(A+B) ). +
      • +
    +
    • +
    +
+
+
+ + + + + +
+
+
+ +
+
+ + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/docs/style.css --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/docs/style.css Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,71 @@ +body + { + font-family: "Trebuchet MS", Trebuchet, "DejaVu Sans", "Luxi Sans", "Liberation Sans", Arial, Helvetica, sans-serif; + color: #000000; + background-color: #FFFFFF; + /* font-size: 10pt; */ + /* line-height: 120%; */ + height: 110%; + } + +/* In the above, "height: 110%;" is a hack for stylistic purposes. + It typically makes the browser place a scroll bar on the left, + thereby reducing the overall width of the page. This is necessary, + as some pages do not have enough content (height wise) to make + the scrollbar appear, while other pages are long enough to have + the scrollbar. When content is centered for stylistic purposes, + the content on "short" pages will be in a different place than + the content on "long" pages. This can be visually annoying when + navigating from a "short" page to a "long" page, or vice versa. + Forcing the scrollbar to always appear removes this problem. +*/ + +pre + { + font-family: "DejaVu Sans Mono", "Liberation Mono", "Andale Mono", "Bitstream Vera Sans Mono", "Luxi Mono", monospace; + font-size: smaller; + color: #666666; + } + +a + { + text-decoration: none; + color: #57a706; + } + +a:hover + { + text-decoration: underline; + color: #57a706; + } + +a.menu + { + text-decoration: none; + color: #CCCCCC; + } + +a.menu:hover + { + text-decoration: none; + color: #57a706; + } + +a.hidden, a.hidden:hover, a.hidden:active, a.hidden:link, a.hidden:visited + { + text-decoration: none; + border-bottom: 0px + } + +table + { + /* border: 1px solid #000; */ + /* display: block; */ + border-collapse: collapse; + } + +td.line + { + border-left: 2px solid rgb(204, 204, 204); + } + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/Makefile Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,109 @@ +# NOTE: +# This file is mainly useful when doing a manual installation of Armadillo. +# It is overwritten by CMake when doing an automatic installation. +# +# You may need to edit this file to reflect the type and capabilities +# of your system. The defaults are for a Linux system and will need +# to be changed for other systems (e.g. Mac OS X). + + +CXX=g++ +#CXX=g++-4.2 +## Under MacOS you may have an old compiler as default (e.g. GCC 4.0). +## However, GCC 4.2 or later is available and preferable due to better +## handling of template code. + +#CXX=CC +## When using the Sun Studio compiler + + +ARMA_INCLUDE_FLAG = -I ../include +## If you've installed Armadillo's headers manually, +## you may need to tell the compiler where they are. +## For example, change ../include to /usr/local/include +## and uncomment the above line. + + +#BOOST_INCLUDE_FLAG = -I /usr/include +## If you have Boost libraries, change /usr/include +## to point to where they are installed and uncomment +## the above line. + + +#EXTRA_LIB_FLAGS = -llapack -lblas +## The above line is an example of the extra libraries +## that can be used by Armadillo. You will also need +## to modify "include/armadillo_bits/config.hpp" +## to indicate which extra libraries are present. +## If you're using Mac OS, comment out the line and +## instead use the line below. + + +#EXTRA_LIB_FLAGS = -framework Accelerate +## Uncomment the above line when using Mac OS +## and modify "include/armadillo_bits/config.hpp" +## to indicate that LAPACK and BLAS libraries +## are present + + +#EXTRA_LIB_FLAGS = -library=sunperf +## When using the Sun Studio compiler + + +LIB_FLAGS = $(EXTRA_LIB_FLAGS) +## NOTE: on Ubuntu and Debian based systems you may need to add +## -lgfortran to LIB_FLAGS + + +OPT = -O1 +## As the Armadillo library uses recursive templates, +## compilation times depend on the level of optimisation: +## +## -O0: quick compilation, but the resulting program will be slow +## -O1: produces programs which achieve most of the possible speedup +## -O3: produces programs which have almost all possible speedups, +## but compilation takes considerably longer + + +#OPT = -xO4 -xannotate=no +## When using the Sun Studio compiler + + +#EXTRA_OPT = -fwhole-program +## Uncomment the above line if you're compiling +## all source files into one program in a single hit. + + +#DEBUG = -DARMA_EXTRA_DEBUG +## Uncomment the above line to enable low-level +## debugging. Lots of debugging information will +## be printed when a compiled program is run. +## Please enable this option when reporting bugs. + + +#FINAL = -DARMA_NO_DEBUG +## Uncomment the above line to disable Armadillo's checks. +## DANGEROUS! Not recommended unless your code has been +## thoroughly tested. + + +# +# +# + +CXXFLAGS = $(ARMA_INCLUDE_FLAG) $(BOOST_INCLUDE_FLAG) $(DEBUG) $(FINAL) $(OPT) $(EXTRA_OPT) + +all: example1 example2 + +example1: example1.cpp + $(CXX) $(CXXFLAGS) -o $@ $< $(LIB_FLAGS) + +example2: example2.cpp + $(CXX) $(CXXFLAGS) -o $@ $< $(LIB_FLAGS) + + +.PHONY: clean + +clean: + rm -f example1 example2 + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/Makefile.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/Makefile.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,86 @@ +# The generated "Makefile" from "Makefile.cmake" is only usable after +# the Armadillo library has been configured and installed by CMake. + +CXX=g++ +#CXX=g++-4.2 +## Under MacOS you may have an old compiler as default (e.g. GCC 4.0). +## However, GCC 4.2 or later is available and preferable due to better +## handling of template code. + +#CXX=CC +## When using the Sun Studio compiler + + +# flags configured by CMake +ifeq (${ARMA_OS},macos) + EXTRA_LIB_FLAGS = -framework Accelerate +endif + +#EXTRA_LIB_FLAGS = -library=sunperf +## When using the Sun Studio compiler + + +ifeq (${ARMA_USE_BOOST},true) + BOOST_INCLUDE_FLAG = -I ${Boost_INCLUDE_DIR} +endif + + + +LIB_FLAGS = -larmadillo $(EXTRA_LIB_FLAGS) +## NOTE: on Ubuntu and Debian based systems you may need to add +## -lgfortran to LIB_FLAGS + + + +OPT = -O1 +## As the Armadillo library uses recursive templates, +## compilation times depend on the level of optimisation: +## +## -O0: quick compilation, but the resulting program will be slow +## -O1: produces programs which achieve most of the possible speedup +## -O3: produces programs which have almost all possible speedups, +## but compilation takes considerably longer + + +#OPT = -xO4 -xannotate=no +## When using the Sun Studio compiler + + +#EXTRA_OPT = -fwhole-program +## Uncomment the above line if you're compiling +## all source files into one program in a single hit. + + +#DEBUG = -DARMA_EXTRA_DEBUG +## Uncomment the above line to enable low-level +## debugging. Lots of debugging information will +## be printed when a compiled program is run. +## Please enable this option when reporting bugs. + + +#FINAL = -DARMA_NO_DEBUG +## Uncomment the above line to disable Armadillo's checks. +## DANGEROUS! Not recommended unless your code has been +## thoroughly tested. + + +# +# +# + +CXXFLAGS = $(BOOST_INCLUDE_FLAG) $(DEBUG) $(FINAL) $(OPT) $(EXTRA_OPT) + +all: example1 example2 + +example1: example1.cpp + $(CXX) $(CXXFLAGS) -o $@ $< $(LIB_FLAGS) + +example2: example2.cpp + $(CXX) $(CXXFLAGS) -o $@ $< $(LIB_FLAGS) + + +.PHONY: clean + +clean: + rm -f example1 example2 + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example1.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example1.cpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,183 @@ +#include + +#include "armadillo" + +using namespace arma; +using namespace std; + + +int main(int argc, char** argv) + { + cout << "Armadillo version: " << arma_version::as_string() << endl; + + // directly specify the matrix size (elements are uninitialised) + mat A(2,3); + + // .n_rows = number of rows (read only) + // .n_cols = number of columns (read only) + cout << "A.n_rows = " << A.n_rows << endl; + cout << "A.n_cols = " << A.n_cols << endl; + + // directly access an element (indexing starts at 0) + A(1,2) = 456.0; + + A.print("A:"); + + // scalars are treated as a 1x1 matrix, + // hence the code below will set A to have a size of 1x1 + A = 5.0; + A.print("A:"); + + // if you want a matrix with all elements set to a particular value + // the .fill() member function can be used + A.set_size(3,3); + A.fill(5.0); + A.print("A:"); + + + mat B; + + // endr indicates "end of row" + B << 0.555950 << 0.274690 << 0.540605 << 0.798938 << endr + << 0.108929 << 0.830123 << 0.891726 << 0.895283 << endr + << 0.948014 << 0.973234 << 0.216504 << 0.883152 << endr + << 0.023787 << 0.675382 << 0.231751 << 0.450332 << endr; + + // print to the cout stream + // with an optional string before the contents of the matrix + B.print("B:"); + + // the << operator can also be used to print the matrix + // to an arbitrary stream (cout in this case) + cout << "B:" << endl << B << endl; + + // save to disk + B.save("B.txt", raw_ascii); + + // load from disk + mat C; + C.load("B.txt"); + + C += 2.0 * B; + C.print("C:"); + + + // submatrix types: + // + // .submat(first_row, first_column, last_row, last_column) + // .row(row_number) + // .col(column_number) + // .cols(first_column, last_column) + // .rows(first_row, last_row) + + cout << "C.submat(0,0,3,1) =" << endl; + cout << C.submat(0,0,3,1) << endl; + + // generate the identity matrix + mat D = eye(4,4); + + D.submat(0,0,3,1) = C.cols(1,2); + D.print("D:"); + + // transpose + cout << "trans(B) =" << endl; + cout << trans(B) << endl; + + // maximum from each column (traverse along rows) + cout << "max(B) =" << endl; + cout << max(B) << endl; + + // maximum from each row (traverse along columns) + cout << "max(B,1) =" << endl; + cout << max(B,1) << endl; + + // maximum value in B + cout << "max(max(B)) = " << max(max(B)) << endl; + + // sum of each column (traverse along rows) + cout << "sum(B) =" << endl; + cout << sum(B) << endl; + + // sum of each row (traverse along columns) + cout << "sum(B,1) =" << endl; + cout << sum(B,1) << endl; + + // sum of all elements + cout << "sum(sum(B)) = " << sum(sum(B)) << endl; + cout << "accu(B) = " << accu(B) << endl; + + // trace = sum along diagonal + cout << "trace(B) = " << trace(B) << endl; + + // random matrix -- values are uniformly distributed in the [0,1] interval + mat E = randu(4,4); + E.print("E:"); + + cout << endl; + + // row vectors are treated like a matrix with one row + rowvec r; + r << 0.59499 << 0.88807 << 0.88532 << 0.19968; + r.print("r:"); + + // column vectors are treated like a matrix with one column + colvec q; + q << 0.81114 << 0.06256 << 0.95989 << 0.73628; + q.print("q:"); + + // dot or inner product + cout << "as_scalar(r*q) = " << as_scalar(r*q) << endl; + + + // outer product + cout << "q*r =" << endl; + cout << q*r << endl; + + // multiply-and-accumulate operation + // (no temporary matrices are created) + cout << "accu(B % C) = " << accu(B % C) << endl; + + // sum of three matrices (no temporary matrices are created) + mat F = B + C + D; + F.print("F:"); + + // imat specifies an integer matrix + imat AA; + imat BB; + + AA << 1 << 2 << 3 << endr << 4 << 5 << 6 << endr << 7 << 8 << 9; + BB << 3 << 2 << 1 << endr << 6 << 5 << 4 << endr << 9 << 8 << 7; + + // comparison of matrices (element-wise) + // output of a relational operator is a umat + umat ZZ = (AA >= BB); + ZZ.print("ZZ ="); + + + // 2D field of arbitrary length row vectors + // (fields can also store abitrary objects, e.g. instances of std::string) + field xyz(3,2); + + xyz(0,0) = randu(1,2); + xyz(1,0) = randu(1,3); + xyz(2,0) = randu(1,4); + xyz(0,1) = randu(1,5); + xyz(1,1) = randu(1,6); + xyz(2,1) = randu(1,7); + + cout << "xyz:" << endl; + cout << xyz << endl; + + + // cubes ("3D matrices") + cube Q( B.n_rows, B.n_cols, 2 ); + + Q.slice(0) = B; + Q.slice(1) = 2.0 * B; + + Q.print("Q:"); + + + return 0; + } + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example1_win32/example1_win32.sln --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example1_win32/example1_win32.sln Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual C++ Express 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example1_win32", "example1_win32.vcproj", "{3D5424A0-4AFB-4477-9D2B-792D5FE32734}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Debug|Win32.ActiveCfg = Debug|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Debug|Win32.Build.0 = Debug|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Release|Win32.ActiveCfg = Release|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example1_win32/example1_win32.vcproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example1_win32/example1_win32.vcproj Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,198 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example2.cpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,70 @@ +#include + +#include "armadillo" + +using namespace arma; +using namespace std; + + +int main(int argc, char** argv) + { + cout << "Armadillo version: " << arma_version::as_string() << endl; + + mat A; + + A << 0.165300 << 0.454037 << 0.995795 << 0.124098 << 0.047084 << endr + << 0.688782 << 0.036549 << 0.552848 << 0.937664 << 0.866401 << endr + << 0.348740 << 0.479388 << 0.506228 << 0.145673 << 0.491547 << endr + << 0.148678 << 0.682258 << 0.571154 << 0.874724 << 0.444632 << endr + << 0.245726 << 0.595218 << 0.409327 << 0.367827 << 0.385736 << endr; + + A.print("A ="); + + // determinant + cout << "det(A) = " << det(A) << endl; + + // inverse + cout << "inv(A) = " << endl << inv(A) << endl; + + + // + + double k = 1.23; + + mat B = randu(5,5); + mat C = randu(5,5); + + rowvec r = randu(5); + colvec q = randu(5); + + + // examples of some expressions + // for which optimised implementations exist + + // optimised implementation of a trinary expression + // that results in a scalar + cout << "as_scalar( r*inv(diagmat(B))*q ) = "; + cout << as_scalar( r*inv(diagmat(B))*q ) << endl; + + // example of an expression which is optimised + // as a call to the dgemm() function in BLAS: + cout << "k*trans(B)*C = " << endl << k*trans(B)*C; + + + // If you want to see a trace of how Armadillo + // evaluates expressions, compile with the + // ARMA_EXTRA_DEBUG macro defined. + // This was designed to work with the GCC compiler, + // but it may also work with other compilers + // if you have the Boost libraries installed + // and told Armadillo to use them. + // + // Example for GCC: + // g++ example2.cpp -o example2 -larmadillo -DARMA_EXTRA_DEBUG + // + // Running example2 will now produce a truckload of messages, + // so you may want to redirect the output to a log file. + + return 0; + } + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example2_win32/example2_win32.sln --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example2_win32/example2_win32.sln Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual C++ Express 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example2_win32", "example2_win32.vcproj", "{3D5424A0-4AFB-4477-9D2B-792D5FE32734}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Debug|Win32.ActiveCfg = Debug|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Debug|Win32.Build.0 = Debug|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Release|Win32.ActiveCfg = Release|Win32 + {3D5424A0-4AFB-4477-9D2B-792D5FE32734}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example2_win32/example2_win32.vcproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example2_win32/example2_win32.vcproj Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,198 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/examples/example_lsq.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/examples/example_lsq.cpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,64 @@ +// Tutorial for linear least square fitting +// Author: Pierre Moulon +// Date: 8 December 2009 +// Objective: +// Fit a 2D line with to a set of points +// Specifically, find a and b in the model y = ax + b +// +// Direct application of the example in: +// http://en.wikipedia.org/wiki/Linear_least_squares#Motivational_example + + +#include + +#include "armadillo" + +using namespace arma; +using namespace std; + + + +int main(int argc, char** argv) + { + // points to which we will fit the line + mat data = "1 6; 2 5; 3 7; 4 10"; + + cout << "Points used for the estimation:" << endl; + cout << data << endl; + + // Build matrices to solve Ax = b problem: + vec b(data.n_rows); + mat C(data.n_rows, 2); + + for(u32 i=0; i +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +#include "armadillo_bits/config.hpp" +#include "armadillo_bits/compiler_setup.hpp" +#include "armadillo_bits/undefine_conflicts.hpp" + + +#if defined(ARMA_USE_CXX11) + #include +#endif + + +#if !defined(ARMA_HAVE_GETTIMEOFDAY) && !defined(ARMA_USE_BOOST_DATE) + #include +#endif + +#if defined(ARMA_HAVE_GETTIMEOFDAY) + #include + #undef ARMA_USE_BOOST_DATE +#endif + + +#if defined(ARMA_USE_BOOST_DATE) + #include +#endif + + +#if defined(ARMA_HAVE_STD_TR1) + // TODO: add handling of this functionality when use of C++11 is enabled + #include + #include +#elif defined(ARMA_USE_BOOST) + #include + #include + #include + #include +#endif + + +#if defined(ARMA_USE_BOOST) + #if defined(ARMA_EXTRA_DEBUG) + #include + #include + #define ARMA_USE_BOOST_FORMAT + #endif +#endif + + +#include "armadillo_bits/include_atlas.hpp" +#include "armadillo_bits/itpp_wrap.hpp" + + +//! \namespace arma namespace for Armadillo classes and functions +namespace arma + { + + // preliminaries + + #include "armadillo_bits/forward_bones.hpp" + #include "armadillo_bits/arma_static_check.hpp" + #include "armadillo_bits/typedef.hpp" + #include "armadillo_bits/typedef_blas_int.hpp" + #include "armadillo_bits/format_wrap.hpp" + #include "armadillo_bits/arma_version.hpp" + #include "armadillo_bits/arma_config.hpp" + #include "armadillo_bits/traits.hpp" + #include "armadillo_bits/promote_type.hpp" + #include "armadillo_bits/upgrade_val.hpp" + #include "armadillo_bits/restrictors.hpp" + #include "armadillo_bits/access.hpp" + #include "armadillo_bits/span.hpp" + #include "armadillo_bits/constants.hpp" + + + // + // class prototypes + + #include "armadillo_bits/Base_bones.hpp" + #include "armadillo_bits/BaseCube_bones.hpp" + + #include "armadillo_bits/blas_bones.hpp" + #include "armadillo_bits/lapack_bones.hpp" + #include "armadillo_bits/atlas_bones.hpp" + + #include "armadillo_bits/blas_wrapper.hpp" + #include "armadillo_bits/lapack_wrapper.hpp" + #include "armadillo_bits/atlas_wrapper.hpp" + + #include "armadillo_bits/arrayops_bones.hpp" + #include "armadillo_bits/podarray_bones.hpp" + #include "armadillo_bits/auxlib_bones.hpp" + + #include "armadillo_bits/injector_bones.hpp" + + #include "armadillo_bits/Mat_bones.hpp" + #include "armadillo_bits/Col_bones.hpp" + #include "armadillo_bits/Row_bones.hpp" + #include "armadillo_bits/Cube_bones.hpp" + + #include "armadillo_bits/typedef_fixed.hpp" + + #include "armadillo_bits/field_bones.hpp" + #include "armadillo_bits/subview_bones.hpp" + #include "armadillo_bits/subview_elem1_bones.hpp" + #include "armadillo_bits/subview_field_bones.hpp" + #include "armadillo_bits/subview_cube_bones.hpp" + #include "armadillo_bits/diagview_bones.hpp" + + + #include "armadillo_bits/diskio_bones.hpp" + #include "armadillo_bits/wall_clock_bones.hpp" + #include "armadillo_bits/running_stat_bones.hpp" + #include "armadillo_bits/running_stat_vec_bones.hpp" + + #include "armadillo_bits/Op_bones.hpp" + #include "armadillo_bits/OpCube_bones.hpp" + + #include "armadillo_bits/eOp_bones.hpp" + #include "armadillo_bits/eOpCube_bones.hpp" + + #include "armadillo_bits/mtOp_bones.hpp" + #include "armadillo_bits/mtOpCube_bones.hpp" + + #include "armadillo_bits/Glue_bones.hpp" + #include "armadillo_bits/eGlue_bones.hpp" + #include "armadillo_bits/mtGlue_bones.hpp" + + #include "armadillo_bits/GlueCube_bones.hpp" + #include "armadillo_bits/eGlueCube_bones.hpp" + #include "armadillo_bits/mtGlueCube_bones.hpp" + + #include "armadillo_bits/eop_core_bones.hpp" + #include "armadillo_bits/eglue_core_bones.hpp" + + #include "armadillo_bits/Gen_bones.hpp" + #include "armadillo_bits/GenCube_bones.hpp" + + #include "armadillo_bits/op_diagmat_bones.hpp" + #include "armadillo_bits/op_diagvec_bones.hpp" + #include "armadillo_bits/op_dot_bones.hpp" + #include "armadillo_bits/op_inv_bones.hpp" + #include "armadillo_bits/op_htrans_bones.hpp" + #include "armadillo_bits/op_max_bones.hpp" + #include "armadillo_bits/op_min_bones.hpp" + #include "armadillo_bits/op_mean_bones.hpp" + #include "armadillo_bits/op_median_bones.hpp" + #include "armadillo_bits/op_sort_bones.hpp" + #include "armadillo_bits/op_sum_bones.hpp" + #include "armadillo_bits/op_stddev_bones.hpp" + #include "armadillo_bits/op_strans_bones.hpp" + #include "armadillo_bits/op_var_bones.hpp" + #include "armadillo_bits/op_repmat_bones.hpp" + #include "armadillo_bits/op_reshape_bones.hpp" + #include "armadillo_bits/op_resize_bones.hpp" + #include "armadillo_bits/op_cov_bones.hpp" + #include "armadillo_bits/op_cor_bones.hpp" + #include "armadillo_bits/op_shuffle_bones.hpp" + #include "armadillo_bits/op_prod_bones.hpp" + #include "armadillo_bits/op_pinv_bones.hpp" + #include "armadillo_bits/op_dotext_bones.hpp" + #include "armadillo_bits/op_flip_bones.hpp" + #include "armadillo_bits/op_princomp_bones.hpp" + #include "armadillo_bits/op_misc_bones.hpp" + #include "armadillo_bits/op_relational_bones.hpp" + #include "armadillo_bits/op_find_bones.hpp" + #include "armadillo_bits/op_chol_bones.hpp" + #include "armadillo_bits/op_cx_scalar_bones.hpp" + #include "armadillo_bits/op_trimat_bones.hpp" + #include "armadillo_bits/op_cumsum_bones.hpp" + #include "armadillo_bits/op_symmat_bones.hpp" + + #include "armadillo_bits/glue_times_bones.hpp" + #include "armadillo_bits/glue_mixed_bones.hpp" + #include "armadillo_bits/glue_cov_bones.hpp" + #include "armadillo_bits/glue_cor_bones.hpp" + #include "armadillo_bits/glue_kron_bones.hpp" + #include "armadillo_bits/glue_cross_bones.hpp" + #include "armadillo_bits/glue_join_bones.hpp" + #include "armadillo_bits/glue_relational_bones.hpp" + #include "armadillo_bits/glue_solve_bones.hpp" + #include "armadillo_bits/glue_conv_bones.hpp" + #include "armadillo_bits/glue_toeplitz_bones.hpp" + + // + // debugging functions + + #include "armadillo_bits/debug.hpp" + + // + // + + #include "armadillo_bits/cmath_wrap.hpp" + + // + // classes that underlay metaprogramming + + #include "armadillo_bits/Proxy.hpp" + #include "armadillo_bits/ProxyCube.hpp" + + #include "armadillo_bits/diagmat_proxy.hpp" + + #include "armadillo_bits/unwrap.hpp" + #include "armadillo_bits/unwrap_cube.hpp" + + #include "armadillo_bits/strip.hpp" + + #include "armadillo_bits/Op_meat.hpp" + #include "armadillo_bits/OpCube_meat.hpp" + + #include "armadillo_bits/mtOp_meat.hpp" + #include "armadillo_bits/mtOpCube_meat.hpp" + + #include "armadillo_bits/Glue_meat.hpp" + #include "armadillo_bits/GlueCube_meat.hpp" + + #include "armadillo_bits/eop_aux.hpp" + + #include "armadillo_bits/eOp_meat.hpp" + #include "armadillo_bits/eOpCube_meat.hpp" + + #include "armadillo_bits/eGlue_meat.hpp" + #include "armadillo_bits/eGlueCube_meat.hpp" + + #include "armadillo_bits/mtGlue_meat.hpp" + #include "armadillo_bits/mtGlueCube_meat.hpp" + + #include "armadillo_bits/Base_meat.hpp" + #include "armadillo_bits/BaseCube_meat.hpp" + + #include "armadillo_bits/Gen_meat.hpp" + #include "armadillo_bits/GenCube_meat.hpp" + + + // + // ostream + + #include "armadillo_bits/arma_ostream_bones.hpp" + #include "armadillo_bits/arma_ostream_meat.hpp" + + + // + // operators + + #include "armadillo_bits/operator_plus.hpp" + #include "armadillo_bits/operator_minus.hpp" + #include "armadillo_bits/operator_times.hpp" + #include "armadillo_bits/operator_schur.hpp" + #include "armadillo_bits/operator_div.hpp" + #include "armadillo_bits/operator_relational.hpp" + + #include "armadillo_bits/operator_cube_plus.hpp" + #include "armadillo_bits/operator_cube_minus.hpp" + #include "armadillo_bits/operator_cube_times.hpp" + #include "armadillo_bits/operator_cube_schur.hpp" + #include "armadillo_bits/operator_cube_div.hpp" + #include "armadillo_bits/operator_cube_relational.hpp" + + #include "armadillo_bits/operator_ostream.hpp" + + + // + // user accessible functions + + // the order of the fn_*.hpp include files matters, + // as some files require functionality given in preceding files + + #include "armadillo_bits/fn_conv_to.hpp" + #include "armadillo_bits/fn_min.hpp" + #include "armadillo_bits/fn_max.hpp" + #include "armadillo_bits/fn_accu.hpp" + #include "armadillo_bits/fn_sum.hpp" + #include "armadillo_bits/fn_diagmat.hpp" + #include "armadillo_bits/fn_diagvec.hpp" + #include "armadillo_bits/fn_inv.hpp" + #include "armadillo_bits/fn_trace.hpp" + #include "armadillo_bits/fn_trans.hpp" + #include "armadillo_bits/fn_det.hpp" + #include "armadillo_bits/fn_log_det.hpp" + #include "armadillo_bits/fn_eig.hpp" + #include "armadillo_bits/fn_lu.hpp" + #include "armadillo_bits/fn_zeros.hpp" + #include "armadillo_bits/fn_ones.hpp" + #include "armadillo_bits/fn_eye.hpp" + #include "armadillo_bits/fn_misc.hpp" + #include "armadillo_bits/fn_elem.hpp" + #include "armadillo_bits/fn_norm.hpp" + #include "armadillo_bits/fn_dot.hpp" + #include "armadillo_bits/fn_randu.hpp" + #include "armadillo_bits/fn_randn.hpp" + #include "armadillo_bits/fn_trig.hpp" + #include "armadillo_bits/fn_mean.hpp" + #include "armadillo_bits/fn_median.hpp" + #include "armadillo_bits/fn_stddev.hpp" + #include "armadillo_bits/fn_var.hpp" + #include "armadillo_bits/fn_sort.hpp" + #include "armadillo_bits/fn_sort_index.hpp" + #include "armadillo_bits/fn_strans.hpp" + #include "armadillo_bits/fn_chol.hpp" + #include "armadillo_bits/fn_qr.hpp" + #include "armadillo_bits/fn_svd.hpp" + #include "armadillo_bits/fn_solve.hpp" + #include "armadillo_bits/fn_repmat.hpp" + #include "armadillo_bits/fn_reshape.hpp" + #include "armadillo_bits/fn_resize.hpp" + #include "armadillo_bits/fn_cov.hpp" + #include "armadillo_bits/fn_cor.hpp" + #include "armadillo_bits/fn_shuffle.hpp" + #include "armadillo_bits/fn_prod.hpp" + #include "armadillo_bits/fn_eps.hpp" + #include "armadillo_bits/fn_pinv.hpp" + #include "armadillo_bits/fn_rank.hpp" + #include "armadillo_bits/fn_kron.hpp" + #include "armadillo_bits/fn_flip.hpp" + #include "armadillo_bits/fn_as_scalar.hpp" + #include "armadillo_bits/fn_princomp.hpp" + #include "armadillo_bits/fn_cross.hpp" + #include "armadillo_bits/fn_join.hpp" + #include "armadillo_bits/fn_conv.hpp" + #include "armadillo_bits/fn_trunc_exp.hpp" + #include "armadillo_bits/fn_trunc_log.hpp" + #include "armadillo_bits/fn_toeplitz.hpp" + #include "armadillo_bits/fn_trimat.hpp" + #include "armadillo_bits/fn_cumsum.hpp" + #include "armadillo_bits/fn_symmat.hpp" + #include "armadillo_bits/fn_syl_lyap.hpp" + + // + // class meat + + #include "armadillo_bits/gemv.hpp" + #include "armadillo_bits/gemm.hpp" + #include "armadillo_bits/gemm_mixed.hpp" + + #include "armadillo_bits/eop_core_meat.hpp" + #include "armadillo_bits/eglue_core_meat.hpp" + + #include "armadillo_bits/arrayops_meat.hpp" + #include "armadillo_bits/podarray_meat.hpp" + #include "armadillo_bits/auxlib_meat.hpp" + + #include "armadillo_bits/injector_meat.hpp" + + #include "armadillo_bits/Mat_meat.hpp" + #include "armadillo_bits/Col_meat.hpp" + #include "armadillo_bits/Row_meat.hpp" + #include "armadillo_bits/Cube_meat.hpp" + #include "armadillo_bits/field_meat.hpp" + #include "armadillo_bits/subview_meat.hpp" + #include "armadillo_bits/subview_elem1_meat.hpp" + #include "armadillo_bits/subview_field_meat.hpp" + #include "armadillo_bits/subview_cube_meat.hpp" + #include "armadillo_bits/diagview_meat.hpp" + + #include "armadillo_bits/diskio_meat.hpp" + #include "armadillo_bits/wall_clock_meat.hpp" + #include "armadillo_bits/running_stat_meat.hpp" + #include "armadillo_bits/running_stat_vec_meat.hpp" + + #include "armadillo_bits/op_diagmat_meat.hpp" + #include "armadillo_bits/op_diagvec_meat.hpp" + #include "armadillo_bits/op_dot_meat.hpp" + #include "armadillo_bits/op_inv_meat.hpp" + #include "armadillo_bits/op_htrans_meat.hpp" + #include "armadillo_bits/op_max_meat.hpp" + #include "armadillo_bits/op_min_meat.hpp" + #include "armadillo_bits/op_mean_meat.hpp" + #include "armadillo_bits/op_median_meat.hpp" + #include "armadillo_bits/op_sort_meat.hpp" + #include "armadillo_bits/op_sum_meat.hpp" + #include "armadillo_bits/op_stddev_meat.hpp" + #include "armadillo_bits/op_strans_meat.hpp" + #include "armadillo_bits/op_var_meat.hpp" + #include "armadillo_bits/op_repmat_meat.hpp" + #include "armadillo_bits/op_reshape_meat.hpp" + #include "armadillo_bits/op_resize_meat.hpp" + #include "armadillo_bits/op_cov_meat.hpp" + #include "armadillo_bits/op_cor_meat.hpp" + #include "armadillo_bits/op_shuffle_meat.hpp" + #include "armadillo_bits/op_prod_meat.hpp" + #include "armadillo_bits/op_pinv_meat.hpp" + #include "armadillo_bits/op_dotext_meat.hpp" + #include "armadillo_bits/op_flip_meat.hpp" + #include "armadillo_bits/op_princomp_meat.hpp" + #include "armadillo_bits/op_misc_meat.hpp" + #include "armadillo_bits/op_relational_meat.hpp" + #include "armadillo_bits/op_find_meat.hpp" + #include "armadillo_bits/op_chol_meat.hpp" + #include "armadillo_bits/op_cx_scalar_meat.hpp" + #include "armadillo_bits/op_trimat_meat.hpp" + #include "armadillo_bits/op_cumsum_meat.hpp" + #include "armadillo_bits/op_symmat_meat.hpp" + + #include "armadillo_bits/glue_times_meat.hpp" + #include "armadillo_bits/glue_mixed_meat.hpp" + #include "armadillo_bits/glue_cov_meat.hpp" + #include "armadillo_bits/glue_cor_meat.hpp" + #include "armadillo_bits/glue_kron_meat.hpp" + #include "armadillo_bits/glue_cross_meat.hpp" + #include "armadillo_bits/glue_join_meat.hpp" + #include "armadillo_bits/glue_relational_meat.hpp" + #include "armadillo_bits/glue_solve_meat.hpp" + #include "armadillo_bits/glue_conv_meat.hpp" + #include "armadillo_bits/glue_toeplitz_meat.hpp" + } + +#endif + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/BaseCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/BaseCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,34 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup BaseCube +//! @{ + + + +//! Analog of the Base class, intended for cubes +template +struct BaseCube + { + arma_inline const derived& get_ref() const; + + inline void print(const std::string extra_text = "") const; + inline void print(std::ostream& user_stream, const std::string extra_text = "") const; + + inline void raw_print(const std::string extra_text = "") const; + inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/BaseCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/BaseCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,77 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup BaseCube +//! @{ + + + +template +arma_inline +const derived& +BaseCube::get_ref() const + { + return static_cast(*this); + } + + + +template +inline +void +BaseCube::print(const std::string extra_text) const + { + const unwrap_cube tmp( (*this).get_ref() ); + + tmp.M.impl_print(extra_text); + } + + + +template +inline +void +BaseCube::print(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap_cube tmp( (*this).get_ref() ); + + tmp.M.impl_print(user_stream, extra_text); + } + + + +template +inline +void +BaseCube::raw_print(const std::string extra_text) const + { + const unwrap_cube tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print(extra_text); + } + + + +template +inline +void +BaseCube::raw_print(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap_cube tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print(user_stream, extra_text); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Base_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Base_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,48 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Base +//! @{ + + + +//! Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP). +//! Used for type-safe downcasting in functions that restrict their input(s) to be classes that are +//! derived from Base (e.g. Mat, Op, Glue, diagview, subview). +//! A Base object can be converted to a Mat object by the unwrap class. + +template +struct Base + { + arma_inline const derived& get_ref() const; + + arma_inline const Op t() const; + arma_inline const Op ht() const; + arma_inline const Op st() const; + + inline void print(const std::string extra_text = "") const; + inline void print(std::ostream& user_stream, const std::string extra_text = "") const; + + inline void raw_print(const std::string extra_text = "") const; + inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const; + + arma_deprecated inline void print_trans(const std::string extra_text = "") const; + arma_deprecated inline void print_trans(std::ostream& user_stream, const std::string extra_text = "") const; + + arma_deprecated inline void raw_print_trans(const std::string extra_text = "") const; + arma_deprecated inline void raw_print_trans(std::ostream& user_stream, const std::string extra_text = "") const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Base_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Base_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,155 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Base +//! @{ + + + +template +arma_inline +const derived& +Base::get_ref() const + { + return static_cast(*this); + } + + + +template +arma_inline +const Op +Base::t() const + { + return Op( (*this).get_ref() ); + } + + + +template +arma_inline +const Op +Base::ht() const + { + return Op( (*this).get_ref() ); + } + + + +template +arma_inline +const Op +Base::st() const + { + return Op( (*this).get_ref() ); + } + + + +template +inline +void +Base::print(const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_print(extra_text); + } + + + +template +inline +void +Base::print(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_print(user_stream, extra_text); + } + + + +template +inline +void +Base::print_trans(const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_print_trans(extra_text); + } + + + +template +inline +void +Base::print_trans(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_print_trans(user_stream, extra_text); + } + + + +template +inline +void +Base::raw_print(const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print(extra_text); + } + + + +template +inline +void +Base::raw_print(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print(user_stream, extra_text); + } + + + +template +inline +void +Base::raw_print_trans(const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print_trans(extra_text); + } + + + +template +inline +void +Base::raw_print_trans(std::ostream& user_stream, const std::string extra_text) const + { + const unwrap tmp( (*this).get_ref() ); + + tmp.M.impl_raw_print_trans(user_stream, extra_text); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Col_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Col_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,171 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Col +//! @{ + +//! Class for column vectors (matrices with only one column) + +template +class Col : public Mat + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline Col(); + inline Col(const Col& X); + inline explicit Col(const uword n_elem); + inline Col(const uword in_rows, const uword in_cols); + + inline Col(const char* text); + inline const Col& operator=(const char* text); + + inline Col(const std::string& text); + inline const Col& operator=(const std::string& text); + + #if defined(ARMA_USE_CXX11) + inline Col(const std::initializer_list& list); + inline const Col& operator=(const std::initializer_list& list); + #endif + + + inline const Col& operator=(const eT val); + + template inline Col(const Base& X); + template inline const Col& operator=(const Base& X); + + inline Col( eT* aux_mem, const uword aux_length, const bool copy_aux_mem = true, const bool strict = true); + inline Col(const eT* aux_mem, const uword aux_length); + + template + inline explicit Col(const Base& A, const Base& B); + + template inline Col(const BaseCube& X); + template inline const Col& operator=(const BaseCube& X); + + inline Col(const subview_cube& X); + inline const Col& operator=(const subview_cube& X); + + inline mat_injector operator<<(const eT val); + + arma_inline eT& row(const uword row_num); + arma_inline eT row(const uword row_num) const; + + arma_inline subview_col rows(const uword in_row1, const uword in_row2); + arma_inline const subview_col rows(const uword in_row1, const uword in_row2) const; + + arma_inline subview_col subvec(const uword in_row1, const uword in_row2); + arma_inline const subview_col subvec(const uword in_row1, const uword in_row2) const; + + arma_inline subview_col subvec(const span& row_span); + arma_inline const subview_col subvec(const span& row_span) const; + + //arma_inline subview_col operator()(const span& row_span); + //arma_inline const subview_col operator()(const span& row_span) const; + + + inline void shed_row (const uword row_num); + inline void shed_rows(const uword in_row1, const uword in_row2); + + inline void insert_rows(const uword row_num, const uword N, const bool set_to_zero = true); + template inline void insert_rows(const uword row_num, const Base& X); + + + typedef eT* row_iterator; + typedef const eT* const_row_iterator; + + inline row_iterator begin_row(const uword row_num); + inline const_row_iterator begin_row(const uword row_num) const; + + inline row_iterator end_row (const uword row_num); + inline const_row_iterator end_row (const uword row_num) const; + + + template + class fixed : public Col + { + private: + + static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc); + + arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; + + arma_inline void mem_setup(); + arma_inline void change_to_row(); + + + public: + + static const uword n_rows = fixed_n_elem; + static const uword n_cols = 1; + static const uword n_elem = fixed_n_elem; + + arma_inline fixed(); + arma_inline fixed(const fixed& X); + inline fixed(const subview_cube& X); + + template inline fixed(const Base& A); + template inline fixed(const Base& A, const Base& B); + + inline fixed( eT* aux_mem, const bool copy_aux_mem = true); + inline fixed(const eT* aux_mem); + + inline fixed(const char* text); + inline fixed(const std::string& text); + + template inline const Col& operator=(const Base& A); + + inline const Col& operator=(const eT val); + inline const Col& operator=(const char* text); + inline const Col& operator=(const std::string& text); + inline const Col& operator=(const subview_cube& X); + + inline subview_row operator()(const uword row_num, const span& col_span); + inline const subview_row operator()(const uword row_num, const span& col_span) const; + + inline subview_col operator()(const span& row_span, const uword col_num ); + inline const subview_col operator()(const span& row_span, const uword col_num ) const; + + inline subview operator()(const span& row_span, const span& col_span); + inline const subview operator()(const span& row_span, const span& col_span) const; + + arma_inline arma_warn_unused eT& operator[] (const uword i); + arma_inline arma_warn_unused eT operator[] (const uword i) const; + arma_inline arma_warn_unused eT& at (const uword i); + arma_inline arma_warn_unused eT at (const uword i) const; + arma_inline arma_warn_unused eT& operator() (const uword i); + arma_inline arma_warn_unused eT operator() (const uword i) const; + + arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT at (const uword in_row, const uword in_col) const; + arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; + + arma_hot inline const Col& fill(const eT val); + arma_hot inline const Col& zeros(); + arma_hot inline const Col& ones(); + }; + + + #ifdef ARMA_EXTRA_COL_PROTO + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_PROTO) + #endif + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Col_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Col_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1187 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Col +//! @{ + + +//! construct an empty column vector +template +inline +Col::Col() + : Mat(0, 1) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + } + + + +template +inline +Col::Col(const Col& X) + : Mat(X.n_elem, 1) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + arrayops::copy((*this).memptr(), X.memptr(), X.n_elem); + } + + + +//! construct a column vector with the specified number of n_elem +template +inline +Col::Col(const uword in_n_elem) + : Mat(in_n_elem, 1) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + } + + + +template +inline +Col::Col(const uword in_n_rows, const uword in_n_cols) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + Mat::init_warm(in_n_rows, in_n_cols); + } + + + +//! construct a column vector from specified text +template +inline +Col::Col(const char* text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + } + + + +//! construct a column vector from specified text +template +inline +const Col& +Col::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + + return *this; + } + + + +//! construct a column vector from specified text +template +inline +Col::Col(const std::string& text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + } + + + +//! construct a column vector from specified text +template +inline +const Col& +Col::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + + return *this; + } + + + +#if defined(ARMA_USE_CXX11) + +template +inline +Col::Col(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(list); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + } + + + +template +inline +const Col& +Col::operator=(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(list); + + std::swap( access::rw(Mat::n_rows), access::rw(Mat::n_cols) ); + + access::rw(Mat::vec_state) = 1; + + return *this; + } + +#endif + + + +template +inline +const Col& +Col::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat::operator=(val); + + return *this; + } + + + +template +template +inline +Col::Col(const Base& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + Mat::operator=(X.get_ref()); + } + + + +template +template +inline +const Col& +Col::operator=(const Base& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X.get_ref()); + + return *this; + } + + + +//! construct a column vector from a given auxiliary array of eTs +template +inline +Col::Col(eT* aux_mem, const uword aux_length, const bool copy_aux_mem, const bool strict) + : Mat(aux_mem, aux_length, 1, copy_aux_mem, strict) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + } + + + +//! construct a column vector from a given auxiliary array of eTs +template +inline +Col::Col(const eT* aux_mem, const uword aux_length) + : Mat(aux_mem, aux_length, 1) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + } + + + +template +template +inline +Col::Col + ( + const Base::pod_type, T1>& A, + const Base::pod_type, T2>& B + ) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + Mat::init(A,B); + } + + + +template +template +inline +Col::Col(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + Mat::operator=(X); + } + + + +template +template +inline +const Col& +Col::operator=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X); + + return *this; + } + + + +template +inline +Col::Col(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 1; + + Mat::operator=(X); + } + + + +template +inline +const Col& +Col::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X); + + return *this; + } + + + +template +inline +mat_injector< Col > +Col::operator<<(const eT val) + { + return mat_injector< Col >(*this, val); + } + + + +template +arma_inline +eT& +Col::row(const uword row_num) + { + arma_debug_check( (row_num >= Mat::n_rows), "Col::row(): out of bounds" ); + + return access::rw(Mat::mem[row_num]); + } + + + +template +arma_inline +eT +Col::row(const uword row_num) const + { + arma_debug_check( (row_num >= Mat::n_rows), "Col::row(): out of bounds" ); + + return Mat::mem[row_num]; + } + + + +template +arma_inline +subview_col +Col::rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview_col(*this, 0, in_row1, subview_n_rows); + } + + + +template +arma_inline +const subview_col +Col::rows(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview_col(*this, 0, in_row1, subview_n_rows); + } + + + +template +arma_inline +subview_col +Col::subvec(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat::n_rows) ), "Col::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview_col(*this, 0, in_row1, subview_n_rows); + } + + + +template +arma_inline +const subview_col +Col::subvec(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat::n_rows) ), "Col::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview_col(*this, 0, in_row1, subview_n_rows); + } + + + +template +arma_inline +subview_col +Col::subvec(const span& row_span) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = Mat::n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword subvec_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + arma_debug_check( ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ), "Col::subvec(): indices out of bounds or incorrectly used"); + + return subview_col(*this, 0, in_row1, subvec_n_rows); + } + + + +template +arma_inline +const subview_col +Col::subvec(const span& row_span) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = Mat::n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword subvec_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + arma_debug_check( ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ), "Col::subvec(): indices out of bounds or incorrectly used"); + + return subview_col(*this, 0, in_row1, subvec_n_rows); + } + + + +// template +// arma_inline +// subview_col +// Col::operator()(const span& row_span) +// { +// arma_extra_debug_sigprint(); +// +// return subvec(row_span); +// } +// +// +// +// template +// arma_inline +// const subview_col +// Col::operator()(const span& row_span) const +// { +// arma_extra_debug_sigprint(); +// +// return subvec(row_span); +// } + + + +//! remove specified row +template +inline +void +Col::shed_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= Mat::n_rows, "Col::shed_row(): out of bounds"); + + shed_rows(row_num, row_num); + } + + + +//! remove specified rows +template +inline +void +Col::shed_rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= Mat::n_rows), + "Col::shed_rows(): indices out of bounds or incorrectly used" + ); + + const uword n_keep_front = in_row1; + const uword n_keep_back = Mat::n_rows - (in_row2 + 1); + + Col X(n_keep_front + n_keep_back); + + eT* X_mem = X.memptr(); + const eT* t_mem = (*this).memptr(); + + if(n_keep_front > 0) + { + arrayops::copy( X_mem, t_mem, n_keep_front ); + } + + if(n_keep_back > 0) + { + arrayops::copy( &(X_mem[n_keep_front]), &(t_mem[in_row2+1]), n_keep_back); + } + + Mat::steal_mem(X); + } + + + +//! insert N rows at the specified row position, +//! optionally setting the elements of the inserted rows to zero +template +inline +void +Col::insert_rows(const uword row_num, const uword N, const bool set_to_zero) + { + arma_extra_debug_sigprint(); + + const uword t_n_rows = Mat::n_rows; + + const uword A_n_rows = row_num; + const uword B_n_rows = t_n_rows - row_num; + + // insertion at row_num == n_rows is in effect an append operation + arma_debug_check( (row_num > t_n_rows), "Col::insert_rows(): out of bounds"); + + if(N > 0) + { + Col out(t_n_rows + N); + + eT* out_mem = out.memptr(); + const eT* t_mem = (*this).memptr(); + + if(A_n_rows > 0) + { + arrayops::copy( out_mem, t_mem, A_n_rows ); + } + + if(B_n_rows > 0) + { + arrayops::copy( &(out_mem[row_num + N]), &(t_mem[row_num]), B_n_rows ); + } + + if(set_to_zero == true) + { + arrayops::inplace_set( &(out_mem[row_num]), eT(0), N ); + } + + Mat::steal_mem(out); + } + } + + + +//! insert the given object at the specified row position; +//! the given object must have one column +template +template +inline +void +Col::insert_rows(const uword row_num, const Base& X) + { + arma_extra_debug_sigprint(); + + Mat::insert_rows(row_num, X); + } + + + +template +inline +typename Col::row_iterator +Col::begin_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "begin_row(): index out of bounds"); + + return Mat::memptr() + row_num; + } + + + +template +inline +typename Col::const_row_iterator +Col::begin_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "begin_row(): index out of bounds"); + + return Mat::memptr() + row_num; + } + + + +template +inline +typename Col::row_iterator +Col::end_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "end_row(): index out of bounds"); + + return Mat::memptr() + row_num + 1; + } + + + +template +inline +typename Col::const_row_iterator +Col::end_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "end_row(): index out of bounds"); + + return Mat::memptr() + row_num + 1; + } + + + +template +template +arma_inline +void +Col::fixed::mem_setup() + { + arma_extra_debug_sigprint(); + + access::rw(Mat::n_rows) = fixed_n_elem; + access::rw(Mat::n_cols) = 1; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 1; + access::rw(Mat::mem_state) = 3; + access::rw(Mat::mem) = (use_extra) ? mem_local_extra : Mat::mem_local; + } + + + +template +template +arma_inline +void +Col::fixed::change_to_row() + { + arma_extra_debug_sigprint(); + + access::rw(Mat::n_cols) = fixed_n_elem; + access::rw(Mat::n_rows) = 1; + } + + + +template +template +arma_inline +Col::fixed::fixed() + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + } + + + +template +template +arma_inline +Col::fixed::fixed(const fixed& X) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + eT* dest = (use_extra) ? mem_local_extra : Mat::mem_local; + + arrayops::copy( dest, X.mem, fixed_n_elem ); + } + + + +template +template +inline +Col::fixed::fixed(const subview_cube& X) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Col::operator=(X); + } + + + +template +template +template +inline +Col::fixed::fixed(const Base& A) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Col::operator=(A.get_ref()); + } + + + +template +template +template +inline +Col::fixed::fixed(const Base& A, const Base& B) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Col::init(A,B); + } + + + +template +template +inline +Col::fixed::fixed(eT* aux_mem, const bool copy_aux_mem) + { + arma_extra_debug_sigprint_this(this); + + access::rw(Mat::n_rows) = fixed_n_elem; + access::rw(Mat::n_cols) = 1; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 1; + access::rw(Mat::mem_state) = 3; + + if(copy_aux_mem == true) + { + eT* dest = (use_extra) ? mem_local_extra : Mat::mem_local; + + access::rw(Mat::mem) = dest; + + arrayops::copy( dest, aux_mem, fixed_n_elem ); + } + else + { + access::rw(Mat::mem) = aux_mem; + } + } + + + +template +template +inline +Col::fixed::fixed(const eT* aux_mem) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + arrayops::copy( const_cast(Mat::mem), aux_mem, fixed_n_elem ); + } + + + +//! NOTE: this function relies on +//! Col::operator=(text), to change vec_state as well as swapping n_rows and n_cols, +//! and Mat::init(), to check that the given vector will not have a different size than fixed_n_elem. +template +template +inline +Col::fixed::fixed(const char* text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + change_to_row(); + + Col::operator=(text); + } + + + +//! NOTE: this function relies on +//! Col::operator=(text), to change vec_state as well as swapping n_rows and n_cols, +//! and Mat::init(), to check that the given vector will not have a different size than fixed_n_elem. +template +template +inline +Col::fixed::fixed(const std::string& text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + change_to_row(); + + Col::operator=(text); + } + + + +template +template +template +const Col& +Col::fixed::operator=(const Base& A) + { + arma_extra_debug_sigprint(); + + Col::operator=(A.get_ref()); + + return *this; + } + + + +template +template +const Col& +Col::fixed::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + Col::operator=(val); + + return *this; + } + + + +template +template +const Col& +Col::fixed::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + change_to_row(); + + Col::operator=(text); + + return *this; + } + + + +template +template +const Col& +Col::fixed::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + change_to_row(); + + Col::operator=(text); + + return *this; + } + + + +template +template +const Col& +Col::fixed::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + Col::operator=(X); + + return *this; + } + + + +template +template +inline +subview_row +Col::fixed::operator()(const uword row_num, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +inline +const subview_row +Col::fixed::operator()(const uword row_num, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +inline +subview_col +Col::fixed::operator()(const span& row_span, const uword col_num) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +const subview_col +Col::fixed::operator()(const span& row_span, const uword col_num) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +subview +Col::fixed::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +inline +const subview +Col::fixed::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Col::fixed::operator[] (const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Col::fixed::operator[] (const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Col::fixed::at(const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Col::fixed::at(const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Col::fixed::operator() (const uword i) + { + arma_debug_check( (i >= fixed_n_elem), "Col::fixed::operator(): out of bounds"); + + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Col::fixed::operator() (const uword i) const + { + arma_debug_check( (i >= fixed_n_elem), "Col::fixed::operator(): out of bounds"); + + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Col::fixed::at(const uword in_row, const uword in_col) + { + return access::rw( Mat::mem[in_row] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Col::fixed::at(const uword in_row, const uword in_col) const + { + return ( Mat::mem[in_row] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Col::fixed::operator() (const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= fixed_n_elem) || (in_col >= 1)), "Col::fixed::operator(): out of bounds" ); + + return access::rw( Mat::mem[in_row] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Col::fixed::operator() (const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= fixed_n_elem) || (in_col >= 1)), "Col::fixed::operator(): out of bounds" ); + + return ( Mat::mem[in_row] ); + } + + + +template +template +arma_hot +inline +const Col& +Col::fixed::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), val, fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Col& +Col::fixed::zeros() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(0), fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Col& +Col::fixed::ones() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(1), fixed_n_elem ); + + return *this; + } + + + +#ifdef ARMA_EXTRA_COL_MEAT + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_MEAT) +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Cube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Cube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,365 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Cube +//! @{ + + + +struct Cube_prealloc + { + static const uword mat_ptrs_size = 4; + static const uword mem_n_elem = 64; + }; + + + +//! Dense cube class + +template +class Cube : public BaseCube< eT, Cube > + { + public: + + typedef eT elem_type; //!< the type of elements stored in the cube + typedef typename get_pod_type::result pod_type; //!< if eT is non-complex, pod_type is same as eT. otherwise, pod_type is the underlying type used by std::complex + + const uword n_rows; //!< number of rows in each slice (read-only) + const uword n_cols; //!< number of columns in each slice (read-only) + const uword n_elem_slice; //!< number of elements in each slice (read-only) + const uword n_slices; //!< number of slices in the cube (read-only) + const uword n_elem; //!< number of elements in the cube (read-only) + const uword mem_state; + + // mem_state = 0: normal cube that can be resized; + // mem_state = 1: use auxiliary memory until change in the number of elements is requested; + // mem_state = 2: use auxiliary memory and don't allow the number of elements to be changed; + // mem_state = 3: fixed size (e.g. via template based size specification). + + + arma_aligned const Mat** const mat_ptrs; //!< pointer to an array containing pointers to Mat instances (one for each slice) + arma_aligned const eT* const mem; //!< pointer to the memory used by the cube (memory is read-only) + + protected: + arma_aligned Mat* mat_ptrs_local[ Cube_prealloc::mat_ptrs_size ]; + arma_aligned eT mem_local[ Cube_prealloc::mem_n_elem ]; + + + public: + + inline ~Cube(); + inline Cube(); + + inline Cube(const uword in_rows, const uword in_cols, const uword in_slices); + + inline Cube( eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices, const bool copy_aux_mem = true, const bool strict = true); + inline Cube(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices); + + arma_inline const Cube& operator=(const eT val); + arma_inline const Cube& operator+=(const eT val); + arma_inline const Cube& operator-=(const eT val); + arma_inline const Cube& operator*=(const eT val); + arma_inline const Cube& operator/=(const eT val); + + inline Cube(const Cube& m); + inline const Cube& operator=(const Cube& m); + inline const Cube& operator+=(const Cube& m); + inline const Cube& operator-=(const Cube& m); + inline const Cube& operator%=(const Cube& m); + inline const Cube& operator/=(const Cube& m); + + template + inline explicit Cube(const BaseCube& A, const BaseCube& B); + + inline Cube(const subview_cube& X); + inline const Cube& operator=(const subview_cube& X); + inline const Cube& operator+=(const subview_cube& X); + inline const Cube& operator-=(const subview_cube& X); + inline const Cube& operator%=(const subview_cube& X); + inline const Cube& operator/=(const subview_cube& X); + + arma_inline Mat& slice(const uword in_slice); + arma_inline const Mat& slice(const uword in_slice) const; + + arma_inline subview_cube slices(const uword in_slice1, const uword in_slice2); + arma_inline const subview_cube slices(const uword in_slice1, const uword in_slice2) const; + + arma_inline subview_cube subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2); + arma_inline const subview_cube subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2) const; + + inline subview_cube subcube(const span& row_span, const span& col_span, const span& slice_span); + inline const subview_cube subcube(const span& row_span, const span& col_span, const span& slice_span) const; + + inline subview_cube operator()(const span& row_span, const span& col_span, const span& slice_span); + inline const subview_cube operator()(const span& row_span, const span& col_span, const span& slice_span) const; + + + inline void shed_slice(const uword slice_num); + + inline void shed_slices(const uword in_slice1, const uword in_slice2); + + inline void insert_slices(const uword slice_num, const uword N, const bool set_to_zero = true); + + template + inline void insert_slices(const uword row_num, const BaseCube& X); + + + template inline Cube(const GenCube& X); + template inline const Cube& operator=(const GenCube& X); + template inline const Cube& operator+=(const GenCube& X); + template inline const Cube& operator-=(const GenCube& X); + template inline const Cube& operator%=(const GenCube& X); + template inline const Cube& operator/=(const GenCube& X); + + template inline Cube(const OpCube& X); + template inline const Cube& operator=(const OpCube& X); + template inline const Cube& operator+=(const OpCube& X); + template inline const Cube& operator-=(const OpCube& X); + template inline const Cube& operator%=(const OpCube& X); + template inline const Cube& operator/=(const OpCube& X); + + template inline Cube(const eOpCube& X); + template inline const Cube& operator=(const eOpCube& X); + template inline const Cube& operator+=(const eOpCube& X); + template inline const Cube& operator-=(const eOpCube& X); + template inline const Cube& operator%=(const eOpCube& X); + template inline const Cube& operator/=(const eOpCube& X); + + template inline Cube(const mtOpCube& X); + template inline const Cube& operator=(const mtOpCube& X); + template inline const Cube& operator+=(const mtOpCube& X); + template inline const Cube& operator-=(const mtOpCube& X); + template inline const Cube& operator%=(const mtOpCube& X); + template inline const Cube& operator/=(const mtOpCube& X); + + template inline Cube(const GlueCube& X); + template inline const Cube& operator=(const GlueCube& X); + template inline const Cube& operator+=(const GlueCube& X); + template inline const Cube& operator-=(const GlueCube& X); + template inline const Cube& operator%=(const GlueCube& X); + template inline const Cube& operator/=(const GlueCube& X); + + template inline Cube(const eGlueCube& X); + template inline const Cube& operator=(const eGlueCube& X); + template inline const Cube& operator+=(const eGlueCube& X); + template inline const Cube& operator-=(const eGlueCube& X); + template inline const Cube& operator%=(const eGlueCube& X); + template inline const Cube& operator/=(const eGlueCube& X); + + template inline Cube(const mtGlueCube& X); + template inline const Cube& operator=(const mtGlueCube& X); + template inline const Cube& operator+=(const mtGlueCube& X); + template inline const Cube& operator-=(const mtGlueCube& X); + template inline const Cube& operator%=(const mtGlueCube& X); + template inline const Cube& operator/=(const mtGlueCube& X); + + + arma_inline arma_warn_unused eT& operator[] (const uword i); + arma_inline arma_warn_unused eT operator[] (const uword i) const; + + arma_inline arma_warn_unused eT& at(const uword i); + arma_inline arma_warn_unused eT at(const uword i) const; + + arma_inline arma_warn_unused eT& operator() (const uword i); + arma_inline arma_warn_unused eT operator() (const uword i) const; + + arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col, const uword in_slice); + arma_inline arma_warn_unused eT at (const uword in_row, const uword in_col, const uword in_slice) const; + + arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col, const uword in_slice); + arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col, const uword in_slice) const; + + arma_inline const Cube& operator++(); + arma_inline void operator++(int); + + arma_inline const Cube& operator--(); + arma_inline void operator--(int); + + arma_inline arma_warn_unused bool is_finite() const; + arma_inline arma_warn_unused bool is_empty() const; + + arma_inline arma_warn_unused bool in_range(const uword i) const; + arma_inline arma_warn_unused bool in_range(const span& x) const; + + arma_inline arma_warn_unused bool in_range(const uword in_row, const uword in_col, const uword in_slice) const; + inline arma_warn_unused bool in_range(const span& row_span, const span& col_span, const span& slice_span) const; + + arma_inline arma_warn_unused eT* memptr(); + arma_inline arma_warn_unused const eT* memptr() const; + + arma_inline arma_warn_unused eT* slice_memptr(const uword slice); + arma_inline arma_warn_unused const eT* slice_memptr(const uword slice) const; + + arma_inline arma_warn_unused eT* slice_colptr(const uword in_slice, const uword in_col); + arma_inline arma_warn_unused const eT* slice_colptr(const uword in_slice, const uword in_col) const; + + inline void impl_print(const std::string& extra_text) const; + inline void impl_print(std::ostream& user_stream, const std::string& extra_text) const; + + inline void impl_raw_print(const std::string& extra_text) const; + inline void impl_raw_print(std::ostream& user_stream, const std::string& extra_text) const; + + inline void set_size(const uword in_rows, const uword in_cols, const uword in_slices); + inline void reshape(const uword in_rows, const uword in_cols, const uword in_slices, const uword dim = 0); + inline void resize(const uword in_rows, const uword in_cols, const uword in_slices); + + template inline void copy_size(const Cube& m); + + inline const Cube& fill(const eT val); + + inline const Cube& zeros(); + inline const Cube& zeros(const uword in_rows, const uword in_cols, const uword in_slices); + + inline const Cube& ones(); + inline const Cube& ones(const uword in_rows, const uword in_cols, const uword in_slices); + + inline const Cube& randu(); + inline const Cube& randu(const uword in_rows, const uword in_cols, const uword in_slices); + + inline const Cube& randn(); + inline const Cube& randn(const uword in_rows, const uword in_cols, const uword in_slices); + + inline void reset(); + + + template inline void set_real(const BaseCube& X); + template inline void set_imag(const BaseCube& X); + + + inline arma_warn_unused eT min() const; + inline arma_warn_unused eT max() const; + + inline eT min(uword& index_of_min_val) const; + inline eT max(uword& index_of_max_val) const; + + inline eT min(uword& row_of_min_val, uword& col_of_min_val, uword& slice_of_min_val) const; + inline eT max(uword& row_of_max_val, uword& col_of_max_val, uword& slice_of_max_val) const; + + + inline bool save(const std::string name, const file_type type = arma_binary, const bool print_status = true) const; + inline bool save( std::ostream& os, const file_type type = arma_binary, const bool print_status = true) const; + + inline bool load(const std::string name, const file_type type = auto_detect, const bool print_status = true); + inline bool load( std::istream& is, const file_type type = auto_detect, const bool print_status = true); + + inline bool quiet_save(const std::string name, const file_type type = arma_binary) const; + inline bool quiet_save( std::ostream& os, const file_type type = arma_binary) const; + + inline bool quiet_load(const std::string name, const file_type type = auto_detect); + inline bool quiet_load( std::istream& is, const file_type type = auto_detect); + + + // iterators + + typedef eT* iterator; + typedef const eT* const_iterator; + + typedef eT* slice_iterator; + typedef const eT* const_slice_iterator; + + inline iterator begin(); + inline const_iterator begin() const; + + inline iterator end(); + inline const_iterator end() const; + + inline slice_iterator begin_slice(const uword slice_num); + inline const_slice_iterator begin_slice(const uword slice_num) const; + + inline slice_iterator end_slice(const uword slice_num); + inline const_slice_iterator end_slice(const uword slice_num) const; + + + template + class fixed : public Cube + { + private: + + static const uword fixed_n_elem = fixed_n_rows * fixed_n_cols * fixed_n_slices; + + arma_aligned Mat* mat_ptrs_local_extra[ (fixed_n_slices > Cube_prealloc::mat_ptrs_size) ? fixed_n_slices : 1 ]; + arma_aligned eT mem_local_extra [ (fixed_n_elem > Cube_prealloc::mem_n_elem) ? fixed_n_elem : 1 ]; + + arma_inline void mem_setup(); + + + public: + + inline fixed() { mem_setup(); } + + inline const Cube& operator=(const eT val) { mem_setup(); Cube::operator=(val); return *this; } + + template + inline fixed(const BaseCube& A) { mem_setup(); Cube::operator=(A.get_ref()); } + + template + inline const Cube& operator=(const BaseCube& A) { Cube::operator=(A.get_ref()); return *this; } + + template + inline explicit fixed(const BaseCube& A, const BaseCube& B) { mem_setup(); Cube::init(A,B); } + }; + + + protected: + + inline void init_cold(); + inline void init_warm(const uword in_rows, const uword in_cols, const uword in_slices); + + template + inline void init(const BaseCube& A, const BaseCube& B); + + inline void steal_mem(Cube& X); + + inline void delete_mat(); + inline void create_mat(); + + friend class glue_join; + friend class op_reshape; + friend class op_resize; + + + public: + + #ifdef ARMA_EXTRA_CUBE_PROTO + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_CUBE_PROTO) + #endif + }; + + + +class Cube_aux + { + public: + + template arma_inline static void prefix_pp(Cube& x); + template arma_inline static void prefix_pp(Cube< std::complex >& x); + + template arma_inline static void postfix_pp(Cube& x); + template arma_inline static void postfix_pp(Cube< std::complex >& x); + + template arma_inline static void prefix_mm(Cube& x); + template arma_inline static void prefix_mm(Cube< std::complex >& x); + + template arma_inline static void postfix_mm(Cube& x); + template arma_inline static void postfix_mm(Cube< std::complex >& x); + + template inline static void set_real(Cube& out, const BaseCube& X); + template inline static void set_imag(Cube& out, const BaseCube& X); + + template inline static void set_real(Cube< std::complex >& out, const BaseCube< T,T1>& X); + template inline static void set_imag(Cube< std::complex >& out, const BaseCube< T,T1>& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Cube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Cube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,3405 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Cube +//! @{ + + +template +inline +Cube::~Cube() + { + arma_extra_debug_sigprint_this(this); + + delete_mat(); + + if(mem_state == 0) + { + if(n_elem > Cube_prealloc::mem_n_elem) + { + #if defined(ARMA_USE_TBB_ALLOC) + scalable_free((void *)(mem)); + #else + delete [] mem; + #endif + } + } + + if(arma_config::debug == true) + { + // try to expose buggy user code that accesses deleted objects + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + access::rw(n_slices) = 0; + access::rw(n_elem) = 0; + access::rw(mat_ptrs) = 0; + access::rw(mem) = 0; + } + + arma_type_check(( is_supported_elem_type::value == false )); + } + + + +template +inline +Cube::Cube() + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + } + + + +//! construct the cube to have user specified dimensions +template +inline +Cube::Cube(const uword in_n_rows, const uword in_n_cols, const uword in_n_slices) + : n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem_slice(in_n_rows*in_n_cols) + , n_slices(in_n_slices) + , n_elem(in_n_rows*in_n_cols*in_n_slices) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + } + + + +template +inline +void +Cube::init_cold() + { + arma_extra_debug_sigprint( arma_boost::format("n_rows = %d, n_cols = %d, n_slices = %d") % n_rows % n_cols % n_slices ); + + arma_debug_check + ( + ( + ( (n_rows > 0x0FFF) || (n_cols > 0x0FFF) || (n_slices > 0xFF) ) + ? ( (float(n_rows) * float(n_cols) * float(n_slices)) > float(ARMA_MAX_UWORD) ) + : false + ), + "Cube::init(): requested size is too large" + ); + + if(n_elem <= Cube_prealloc::mem_n_elem) + { + access::rw(mem) = mem_local; + } + else + { + arma_extra_debug_print("Cube::init(): allocating memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + access::rw(mem) = (eT *)scalable_malloc(sizeof(eT)*n_elem); + #else + access::rw(mem) = new(std::nothrow) eT[n_elem]; + #endif + + arma_check_bad_alloc( (mem == 0), "Cube::init(): out of memory" ); + } + + + if(n_elem == 0) + { + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + access::rw(n_elem_slice) = 0; + access::rw(n_slices) = 0; + } + else + { + create_mat(); + } + } + + + +//! internal cube construction; if the requested size is small enough, memory from the stack is used. +//! otherwise memory is allocated via 'new' +template +inline +void +Cube::init_warm(const uword in_n_rows, const uword in_n_cols, const uword in_n_slices) + { + arma_extra_debug_sigprint( arma_boost::format("in_n_rows = %d, in_n_cols = %d, in_n_slices = %d") % in_n_rows % in_n_cols % in_n_slices ); + + if( (n_rows == in_n_rows) && (n_cols == in_n_cols) && (n_slices == in_n_slices) ) + { + return; + } + + const uword t_mem_state = mem_state; + + bool err_state = false; + char* err_msg = 0; + + arma_debug_set_error + ( + err_state, + err_msg, + (t_mem_state == 3), + "Cube::init(): size is fixed and hence cannot be changed" + ); + + arma_debug_set_error + ( + err_state, + err_msg, + ( + ( (in_n_rows > 0x0FFF) || (in_n_cols > 0x0FFF) || (in_n_slices > 0xFF) ) + ? ( (float(in_n_rows) * float(in_n_cols) * float(in_n_slices)) > float(ARMA_MAX_UWORD) ) + : false + ), + "Cube::init(): requested size is too large" + ); + + arma_debug_check(err_state, err_msg); + + const uword old_n_elem = n_elem; + const uword new_n_elem = in_n_rows * in_n_cols * in_n_slices; + + if(old_n_elem == new_n_elem) + { + delete_mat(); + + if(new_n_elem > 0) + { + access::rw(n_rows) = in_n_rows; + access::rw(n_cols) = in_n_cols; + access::rw(n_elem_slice) = in_n_rows*in_n_cols; + access::rw(n_slices) = in_n_slices; + + create_mat(); + } + } + else + { + arma_debug_check( (t_mem_state == 2), "Cube::init(): requested size is not compatible with the size of auxiliary memory" ); + + delete_mat(); + + if(t_mem_state == 0) + { + if(n_elem > Cube_prealloc::mem_n_elem ) + { + arma_extra_debug_print("Cube::init(): freeing memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + scalable_free((void *)(mem)); + #else + delete [] mem; + #endif + } + } + + access::rw(mem_state) = 0; + + if(new_n_elem <= Cube_prealloc::mem_n_elem) + { + access::rw(mem) = mem_local; + } + else + { + arma_extra_debug_print("Cube::init(): allocating memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + access::rw(mem) = (eT *)scalable_malloc(sizeof(eT)*new_n_elem); + #else + access::rw(mem) = new(std::nothrow) eT[new_n_elem]; + #endif + + arma_check_bad_alloc( (mem == 0), "Cube::init(): out of memory" ); + } + + if(new_n_elem > 0) + { + access::rw(n_rows) = in_n_rows; + access::rw(n_cols) = in_n_cols; + access::rw(n_elem_slice) = in_n_rows*in_n_cols; + access::rw(n_slices) = in_n_slices; + access::rw(n_elem) = new_n_elem; + + create_mat(); + } + } + + + if(new_n_elem == 0) + { + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + access::rw(n_elem_slice) = 0; + access::rw(n_slices) = 0; + access::rw(n_elem) = 0; + } + } + + + +//! for constructing a complex cube out of two non-complex cubes +template +template +inline +void +Cube::init + ( + const BaseCube::pod_type,T1>& A, + const BaseCube::pod_type,T2>& B + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type T; + typedef typename ProxyCube::ea_type ea_type1; + typedef typename ProxyCube::ea_type ea_type2; + + arma_type_check(( is_complex::value == false )); //!< compile-time abort if eT isn't std::complex + arma_type_check(( is_complex< T>::value == true )); //!< compile-time abort if T is std::complex + + arma_type_check(( is_same_type< std::complex, eT >::value == false )); //!< compile-time abort if types are not compatible + + const ProxyCube X(A.get_ref()); + const ProxyCube Y(B.get_ref()); + + arma_assert_same_size(X, Y, "Cube()"); + + init_warm(X.get_n_rows(), X.get_n_cols(), X.get_n_slices()); + + const uword N = n_elem; + eT* out_mem = memptr(); + ea_type1 PX = X.get_ea(); + ea_type2 PY = Y.get_ea(); + + for(uword i=0; i(PX[i], PY[i]); + } + } + + + +//! try to steal the memory from a given cube; +//! if memory can't be stolen, copy the given cube +template +inline +void +Cube::steal_mem(Cube& x) + { + arma_extra_debug_sigprint(); + + if(this != &x) + { + if( (x.mem_state == 0) && (x.n_elem > Cube_prealloc::mem_n_elem) ) + { + reset(); + + const uword x_n_slices = x.n_slices; + + access::rw(n_rows) = x.n_rows; + access::rw(n_cols) = x.n_cols; + access::rw(n_elem_slice) = x.n_elem_slice; + access::rw(n_slices) = x_n_slices; + access::rw(n_elem) = x.n_elem; + access::rw(mem) = x.mem; + + if(x_n_slices > Cube_prealloc::mat_ptrs_size) + { + access::rw( mat_ptrs) = x.mat_ptrs; + access::rw(x.mat_ptrs) = 0; + } + else + { + access::rw(mat_ptrs) = const_cast< const Mat** >(mat_ptrs_local); + + for(uword i=0; i < x_n_slices; ++i) + { + mat_ptrs[i] = x.mat_ptrs[i]; + x.mat_ptrs[i] = 0; + } + } + + access::rw(x.n_rows) = 0; + access::rw(x.n_cols) = 0; + access::rw(x.n_elem_slice) = 0; + access::rw(x.n_slices) = 0; + access::rw(x.n_elem) = 0; + access::rw(x.mem) = 0; + } + else + { + (*this).operator=(x); + } + } + } + + + +template +inline +void +Cube::delete_mat() + { + arma_extra_debug_sigprint(); + + for(uword slice = 0; slice < n_slices; ++slice) + { + delete access::rw(mat_ptrs[slice]); + } + + if(mem_state <= 2) + { + if(n_slices > Cube_prealloc::mat_ptrs_size) + { + delete [] mat_ptrs; + } + } + } + + + +template +inline +void +Cube::create_mat() + { + arma_extra_debug_sigprint(); + + if(mem_state <= 2) + { + if(n_slices <= Cube_prealloc::mat_ptrs_size) + { + access::rw(mat_ptrs) = const_cast< const Mat** >(mat_ptrs_local); + } + else + { + access::rw(mat_ptrs) = new(std::nothrow) const Mat*[n_slices]; + + arma_check_bad_alloc( (mat_ptrs == 0), "Cube::create_mat(): out of memory" ); + } + } + + for(uword slice = 0; slice < n_slices; ++slice) + { + mat_ptrs[slice] = new Mat('j', slice_memptr(slice), n_rows, n_cols); + } + } + + + +//! Set the cube to be equal to the specified scalar. +//! NOTE: the size of the cube will be 1x1x1 +template +arma_inline +const Cube& +Cube::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + init_warm(1,1,1); + access::rw(mem[0]) = val; + return *this; + } + + + +//! In-place addition of a scalar to all elements of the cube +template +arma_inline +const Cube& +Cube::operator+=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_plus( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place subtraction of a scalar from all elements of the cube +template +arma_inline +const Cube& +Cube::operator-=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_minus( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place multiplication of all elements of the cube with a scalar +template +arma_inline +const Cube& +Cube::operator*=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_mul( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place division of all elements of the cube with a scalar +template +arma_inline +const Cube& +Cube::operator/=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_div( memptr(), val, n_elem ); + + return *this; + } + + + +//! construct a cube from a given cube +template +inline +Cube::Cube(const Cube& x) + : n_rows(x.n_rows) + , n_cols(x.n_cols) + , n_elem_slice(x.n_elem_slice) + , n_slices(x.n_slices) + , n_elem(x.n_elem) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + arma_extra_debug_sigprint(arma_boost::format("this = %x in_cube = %x") % this % &x); + + init_cold(); + + arrayops::copy( memptr(), x.mem, n_elem ); + } + + + +//! construct a cube from a given cube +template +inline +const Cube& +Cube::operator=(const Cube& x) + { + arma_extra_debug_sigprint(arma_boost::format("this = %x in_cube = %x") % this % &x); + + if(this != &x) + { + init_warm(x.n_rows, x.n_cols, x.n_slices); + + arrayops::copy( memptr(), x.mem, n_elem ); + } + + return *this; + } + + + +//! construct a cube from a given auxiliary array of eTs. +//! if copy_aux_mem is true, new memory is allocated and the array is copied. +//! if copy_aux_mem is false, the auxiliary array is used directly (without allocating memory and copying). +//! note that in the latter case +//! the default is to copy the array. + +template +inline +Cube::Cube(eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices, const bool copy_aux_mem, const bool strict) + : n_rows ( aux_n_rows ) + , n_cols ( aux_n_cols ) + , n_elem_slice( aux_n_rows*aux_n_cols ) + , n_slices ( aux_n_slices ) + , n_elem ( aux_n_rows*aux_n_cols*aux_n_slices ) + , mem_state ( copy_aux_mem ? 0 : (strict ? 2 : 1) ) + , mat_ptrs ( 0 ) + , mem ( copy_aux_mem ? 0 : aux_mem ) + { + arma_extra_debug_sigprint_this(this); + + if(copy_aux_mem == true) + { + init_cold(); + + arrayops::copy( memptr(), aux_mem, n_elem ); + } + else + { + create_mat(); + } + } + + + +//! construct a cube from a given auxiliary read-only array of eTs. +//! the array is copied. +template +inline +Cube::Cube(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const uword aux_n_slices) + : n_rows(aux_n_rows) + , n_cols(aux_n_cols) + , n_elem_slice(aux_n_rows*aux_n_cols) + , n_slices(aux_n_slices) + , n_elem(aux_n_rows*aux_n_cols*aux_n_slices) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + arrayops::copy( memptr(), aux_mem, n_elem ); + } + + + +//! in-place cube addition +template +inline +const Cube& +Cube::operator+=(const Cube& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "cube addition"); + + arrayops::inplace_plus( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place cube subtraction +template +inline +const Cube& +Cube::operator-=(const Cube& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "cube subtraction"); + + arrayops::inplace_minus( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place element-wise cube multiplication +template +inline +const Cube& +Cube::operator%=(const Cube& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "element-wise cube multiplication"); + + arrayops::inplace_mul( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place element-wise cube division +template +inline +const Cube& +Cube::operator/=(const Cube& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "element-wise cube division"); + + arrayops::inplace_div( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! for constructing a complex cube out of two non-complex cubes +template +template +inline +Cube::Cube + ( + const BaseCube::pod_type,T1>& A, + const BaseCube::pod_type,T2>& B + ) + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + init(A,B); + } + + + +//! construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation) +template +inline +Cube::Cube(const subview_cube& X) + : n_rows(X.n_rows) + , n_cols(X.n_cols) + , n_elem_slice(X.n_elem_slice) + , n_slices(X.n_slices) + , n_elem(X.n_elem) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + subview_cube::extract(*this, X); + } + + + +//! construct a cube from a subview_cube instance (e.g. construct a cube from a delayed subcube operation) +template +inline +const Cube& +Cube::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + const bool alias = (this == &(X.m)); + + if(alias == false) + { + init_warm(X.n_rows, X.n_cols, X.n_slices); + + subview_cube::extract(*this, X); + } + else + { + Cube tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +//! in-place cube addition (using a subcube on the right-hand-side) +template +inline +const Cube& +Cube::operator+=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::plus_inplace(*this, X); + + return *this; + } + + + +//! in-place cube subtraction (using a subcube on the right-hand-side) +template +inline +const Cube& +Cube::operator-=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::minus_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise cube mutiplication (using a subcube on the right-hand-side) +template +inline +const Cube& +Cube::operator%=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::schur_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise cube division (using a subcube on the right-hand-side) +template +inline +const Cube& +Cube::operator/=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::div_inplace(*this, X); + + return *this; + } + + + +//! provide the reference to the matrix representing a single slice +template +arma_inline +Mat& +Cube::slice(const uword in_slice) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_slice >= n_slices), + "Cube::slice(): index out of bounds" + ); + + return const_cast< Mat& >( *(mat_ptrs[in_slice]) ); + } + + + +//! provide the reference to the matrix representing a single slice +template +arma_inline +const Mat& +Cube::slice(const uword in_slice) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_slice >= n_slices), + "Cube::slice(): index out of bounds" + ); + + return *(mat_ptrs[in_slice]); + } + + + +//! creation of subview_cube (subcube comprised of specified slices) +template +arma_inline +subview_cube +Cube::slices(const uword in_slice1, const uword in_slice2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_slice1 > in_slice2) || (in_slice2 >= n_slices), + "Cube::slices(): indices out of bounds or incorrectly used" + ); + + const uword subcube_n_slices = in_slice2 - in_slice1 + 1; + + return subview_cube(*this, 0, 0, in_slice1, n_rows, n_cols, subcube_n_slices); + } + + + +//! creation of subview_cube (subcube comprised of specified slices) +template +arma_inline +const subview_cube +Cube::slices(const uword in_slice1, const uword in_slice2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_slice1 > in_slice2) || (in_slice2 >= n_slices), + "Cube::rows(): indices out of bounds or incorrectly used" + ); + + const uword subcube_n_slices = in_slice2 - in_slice1 + 1; + + return subview_cube(*this, 0, 0, in_slice1, n_rows, n_cols, subcube_n_slices); + } + + + +//! creation of subview_cube (generic subcube) +template +arma_inline +subview_cube +Cube::subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_slice1 > in_slice2) || + (in_row2 >= n_rows) || (in_col2 >= n_cols) || (in_slice2 >= n_slices), + "Cube::subcube(): indices out of bounds or incorrectly used" + ); + + const uword subcube_n_rows = in_row2 - in_row1 + 1; + const uword subcube_n_cols = in_col2 - in_col1 + 1; + const uword subcube_n_slices = in_slice2 - in_slice1 + 1; + + return subview_cube(*this, in_row1, in_col1, in_slice1, subcube_n_rows, subcube_n_cols, subcube_n_slices); + } + + + +//! creation of subview_cube (generic subcube) +template +arma_inline +const subview_cube +Cube::subcube(const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_row2, const uword in_col2, const uword in_slice2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_slice1 > in_slice2) || + (in_row2 >= n_rows) || (in_col2 >= n_cols) || (in_slice2 >= n_slices), + "Cube::subcube(): indices out of bounds or incorrectly used" + ); + + const uword subcube_n_rows = in_row2 - in_row1 + 1; + const uword subcube_n_cols = in_col2 - in_col1 + 1; + const uword subcube_n_slices = in_slice2 - in_slice1 + 1; + + return subview_cube(*this, in_row1, in_col1, in_slice1, subcube_n_rows, subcube_n_cols, subcube_n_slices); + } + + + +//! creation of subview_cube (generic subcube) +template +inline +subview_cube +Cube::subcube(const span& row_span, const span& col_span, const span& slice_span) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + const bool slice_all = slice_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword subcube_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword subcube_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + const uword in_slice1 = slice_all ? 0 : slice_span.a; + const uword in_slice2 = slice_span.b; + const uword subcube_n_slices = slice_all ? local_n_slices : in_slice2 - in_slice1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + || + ( slice_all ? false : ((in_slice1 > in_slice2) || (in_slice2 >= local_n_slices)) ) + , + "Cube::subcube(): indices out of bounds or incorrectly used" + ); + + return subview_cube(*this, in_row1, in_col1, in_slice1, subcube_n_rows, subcube_n_cols, subcube_n_slices); + } + + + +//! creation of subview_cube (generic subcube) +template +inline +const subview_cube +Cube::subcube(const span& row_span, const span& col_span, const span& slice_span) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + const bool slice_all = slice_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword subcube_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword subcube_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + const uword in_slice1 = slice_all ? 0 : slice_span.a; + const uword in_slice2 = slice_span.b; + const uword subcube_n_slices = slice_all ? local_n_slices : in_slice2 - in_slice1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + || + ( slice_all ? false : ((in_slice1 > in_slice2) || (in_slice2 >= local_n_slices)) ) + , + "Cube::subcube(): indices out of bounds or incorrectly used" + ); + + return subview_cube(*this, in_row1, in_col1, in_slice1, subcube_n_rows, subcube_n_cols, subcube_n_slices); + } + + + +template +inline +subview_cube +Cube::operator()(const span& row_span, const span& col_span, const span& slice_span) + { + arma_extra_debug_sigprint(); + + return (*this).subcube(row_span, col_span, slice_span); + } + + + +template +inline +const subview_cube +Cube::operator()(const span& row_span, const span& col_span, const span& slice_span) const + { + arma_extra_debug_sigprint(); + + return (*this).subcube(row_span, col_span, slice_span); + } + + + +//! remove specified slice +template +inline +void +Cube::shed_slice(const uword slice_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( slice_num >= n_slices, "Cube::shed_slice(): out of bounds"); + + shed_slices(slice_num, slice_num); + } + + + +//! remove specified slices +template +inline +void +Cube::shed_slices(const uword in_slice1, const uword in_slice2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_slice1 > in_slice2) || (in_slice2 >= n_slices), + "Cube::shed_slices(): indices out of bounds or incorrectly used" + ); + + const uword n_keep_front = in_slice1; + const uword n_keep_back = n_slices - (in_slice2 + 1); + + Cube X(n_rows, n_cols, n_keep_front + n_keep_back); + + if(n_keep_front > 0) + { + X.slices( 0, (n_keep_front-1) ) = slices( 0, (in_slice1-1) ); + } + + if(n_keep_back > 0) + { + X.slices( n_keep_front, (n_keep_front+n_keep_back-1) ) = slices( (in_slice2+1), (n_slices-1) ); + } + + steal_mem(X); + } + + + +//! insert N slices at the specified slice position, +//! optionally setting the elements of the inserted slices to zero +template +inline +void +Cube::insert_slices(const uword slice_num, const uword N, const bool set_to_zero) + { + arma_extra_debug_sigprint(); + + const uword t_n_slices = n_slices; + + const uword A_n_slices = slice_num; + const uword B_n_slices = t_n_slices - slice_num; + + // insertion at slice_num == n_slices is in effect an append operation + arma_debug_check( (slice_num > t_n_slices), "Cube::insert_slices(): out of bounds"); + + if(N > 0) + { + Cube out(n_rows, n_cols, t_n_slices + N); + + if(A_n_slices > 0) + { + out.slices(0, A_n_slices-1) = slices(0, A_n_slices-1); + } + + if(B_n_slices > 0) + { + out.slices(slice_num + N, t_n_slices + N - 1) = slices(slice_num, t_n_slices-1); + } + + if(set_to_zero == true) + { + //out.slices(slice_num, slice_num + N - 1).zeros(); + + for(uword i=slice_num; i < (slice_num + N); ++i) + { + out.slice(i).zeros(); + } + } + + steal_mem(out); + } + } + + + +//! insert the given object at the specified slice position; +//! the given object must have the same number of rows and columns as the cube +template +template +inline +void +Cube::insert_slices(const uword slice_num, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(X.get_ref()); + const Cube& C = tmp.M; + + const uword N = C.n_slices; + + const uword t_n_slices = n_slices; + + const uword A_n_slices = slice_num; + const uword B_n_slices = t_n_slices - slice_num; + + // insertion at slice_num == n_slices is in effect an append operation + arma_debug_check( (slice_num > t_n_slices), "Cube::insert_slices(): out of bounds"); + + arma_debug_check + ( + ( (C.n_rows != n_rows) || (C.n_cols != n_cols) ), + "Cube::insert_slices(): given object has an incompatible dimensions" + ); + + if(N > 0) + { + Cube out(n_rows, n_cols, t_n_slices + N); + + if(A_n_slices > 0) + { + out.slices(0, A_n_slices-1) = slices(0, A_n_slices-1); + } + + if(B_n_slices > 0) + { + out.slices(slice_num + N, t_n_slices + N - 1) = slices(slice_num, t_n_slices - 1); + } + + out.slices(slice_num, slice_num + N - 1) = C; + + steal_mem(out); + } + } + + + +//! create a cube from OpCube, i.e. run the previously delayed unary operations +template +template +inline +Cube::Cube(const GenCube& X) + : n_rows(X.n_rows) + , n_cols(X.n_cols) + , n_elem_slice(X.n_rows*X.n_cols) + , n_slices(X.n_slices) + , n_elem(X.n_rows*X.n_cols*X.n_slices) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + X.apply(*this); + } + + + +template +template +inline +const Cube& +Cube::operator=(const GenCube& X) + { + arma_extra_debug_sigprint(); + + init_warm(X.n_rows, X.n_cols, X.n_slices); + + X.apply(*this); + + return *this; + } + + + +template +template +inline +const Cube& +Cube::operator+=(const GenCube& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_plus(*this); + + return *this; + } + + + +template +template +inline +const Cube& +Cube::operator-=(const GenCube& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_minus(*this); + + return *this; + } + + + +template +template +inline +const Cube& +Cube::operator%=(const GenCube& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_schur(*this); + + return *this; + } + + + +template +template +inline +const Cube& +Cube::operator/=(const GenCube& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_div(*this); + + return *this; + } + + + +//! create a cube from OpCube, i.e. run the previously delayed unary operations +template +template +inline +Cube::Cube(const OpCube& X) + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + op_type::apply(*this, X); + } + + + +//! create a cube from OpCube, i.e. run the previously delayed unary operations +template +template +inline +const Cube& +Cube::operator=(const OpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + op_type::apply(*this, X); + + return *this; + } + + + +//! in-place cube addition, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator+=(const OpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator+=(m); + } + + + +//! in-place cube subtraction, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator-=(const OpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator-=(m); + } + + + +//! in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator%=(const OpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator%=(m); + } + + + +//! in-place cube element-wise division, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator/=(const OpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator/=(m); + } + + + +//! create a cube from eOpCube, i.e. run the previously delayed unary operations +template +template +inline +Cube::Cube(const eOpCube& X) + : n_rows(X.get_n_rows()) + , n_cols(X.get_n_cols()) + , n_elem_slice(X.get_n_elem_slice()) + , n_slices(X.get_n_slices()) + , n_elem(X.get_n_elem()) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + init_cold(); + + eop_type::apply(*this, X); + } + + + +//! create a cube from eOpCube, i.e. run the previously delayed unary operations +template +template +inline +const Cube& +Cube::operator=(const eOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const bool bad_alias = ( X.P.has_subview && X.P.is_alias(*this) ); + + if(bad_alias == false) + { + init_warm(X.get_n_rows(), X.get_n_cols(), X.get_n_slices()); + + eop_type::apply(*this, X); + } + else + { + Cube tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +//! in-place cube addition, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator+=(const eOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_plus(*this, X); + + return *this; + } + + + +//! in-place cube subtraction, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator-=(const eOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_minus(*this, X); + + return *this; + } + + + +//! in-place cube element-wise multiplication, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator%=(const eOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_schur(*this, X); + + return *this; + } + + + +//! in-place cube element-wise division, with the right-hand-side operand having delayed operations +template +template +inline +const Cube& +Cube::operator/=(const eOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_div(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +Cube::Cube(const mtOpCube& X) + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + op_type::apply(*this, X); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator=(const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + op_type::apply(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator+=(const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator+=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator-=(const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator-=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator%=(const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator%=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator/=(const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator/=(m); + } + + + +//! create a cube from Glue, i.e. run the previously delayed binary operations +template +template +inline +Cube::Cube(const GlueCube& X) + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + this->operator=(X); + } + + + +//! create a cube from Glue, i.e. run the previously delayed binary operations +template +template +inline +const Cube& +Cube::operator=(const GlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + glue_type::apply(*this, X); + + return *this; + } + + +//! in-place cube addition, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator+=(const GlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator+=(m); + } + + + +//! in-place cube subtraction, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator-=(const GlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator-=(m); + } + + + +//! in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator%=(const GlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator%=(m); + } + + + +//! in-place cube element-wise division, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator/=(const GlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Cube m(X); + + return (*this).operator/=(m); + } + + + +//! create a cube from eGlue, i.e. run the previously delayed binary operations +template +template +inline +Cube::Cube(const eGlueCube& X) + : n_rows(X.get_n_rows()) + , n_cols(X.get_n_cols()) + , n_elem_slice(X.get_n_elem_slice()) + , n_slices(X.get_n_slices()) + , n_elem(X.get_n_elem()) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + init_cold(); + + eglue_type::apply(*this, X); + } + + + +//! create a cube from Glue, i.e. run the previously delayed binary operations +template +template +inline +const Cube& +Cube::operator=(const eGlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const bool bad_alias = ( (X.P1.has_subview && X.P1.is_alias(*this)) || (X.P2.has_subview && X.P2.is_alias(*this)) ); + + if(bad_alias == false) + { + init_warm(X.get_n_rows(), X.get_n_cols(), X.get_n_slices()); + + eglue_type::apply(*this, X); + } + else + { + Cube tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +//! in-place cube addition, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator+=(const eGlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_plus(*this, X); + + return *this; + } + + + +//! in-place cube subtraction, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator-=(const eGlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_minus(*this, X); + + return *this; + } + + + +//! in-place cube element-wise multiplication, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator%=(const eGlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_schur(*this, X); + + return *this; + } + + + +//! in-place cube element-wise division, with the right-hand-side operands having delayed operations +template +template +inline +const Cube& +Cube::operator/=(const eGlueCube& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_div(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +Cube::Cube(const mtGlueCube& X) + : n_rows(0) + , n_cols(0) + , n_elem_slice(0) + , n_slices(0) + , n_elem(0) + , mem_state(0) + , mat_ptrs() + , mem() + { + arma_extra_debug_sigprint_this(this); + + glue_type::apply(*this, X); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator=(const mtGlueCube& X) + { + arma_extra_debug_sigprint(); + + glue_type::apply(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator+=(const mtGlueCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator+=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator-=(const mtGlueCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator-=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator%=(const mtGlueCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator%=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Cube& +Cube::operator/=(const mtGlueCube& X) + { + arma_extra_debug_sigprint(); + + const Cube m(X); + + return (*this).operator/=(m); + } + + + +//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT& +Cube::operator() (const uword i) + { + arma_debug_check( (i >= n_elem), "Cube::operator(): index out of bounds"); + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT +Cube::operator() (const uword i) const + { + arma_debug_check( (i >= n_elem), "Cube::operator(): index out of bounds"); + return mem[i]; + } + + +//! linear element accessor (treats the cube as a vector); no bounds check. +template +arma_inline +arma_warn_unused +eT& +Cube::operator[] (const uword i) + { + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the cube as a vector); no bounds check +template +arma_inline +arma_warn_unused +eT +Cube::operator[] (const uword i) const + { + return mem[i]; + } + + + +//! linear element accessor (treats the cube as a vector); no bounds check. +template +arma_inline +arma_warn_unused +eT& +Cube::at(const uword i) + { + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the cube as a vector); no bounds check +template +arma_inline +arma_warn_unused +eT +Cube::at(const uword i) const + { + return mem[i]; + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT& +Cube::operator() (const uword in_row, const uword in_col, const uword in_slice) + { + arma_debug_check + ( + (in_row >= n_rows) || + (in_col >= n_cols) || + (in_slice >= n_slices) + , + "Cube::operator(): index out of bounds" + ); + + return access::rw(mem[in_slice*n_elem_slice + in_col*n_rows + in_row]); + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT +Cube::operator() (const uword in_row, const uword in_col, const uword in_slice) const + { + arma_debug_check + ( + (in_row >= n_rows) || + (in_col >= n_cols) || + (in_slice >= n_slices) + , + "Cube::operator(): index out of bounds" + ); + + return mem[in_slice*n_elem_slice + in_col*n_rows + in_row]; + } + + + +//! element accessor; no bounds check +template +arma_inline +arma_warn_unused +eT& +Cube::at(const uword in_row, const uword in_col, const uword in_slice) + { + return access::rw( mem[in_slice*n_elem_slice + in_col*n_rows + in_row] ); + } + + + +//! element accessor; no bounds check +template +arma_inline +arma_warn_unused +eT +Cube::at(const uword in_row, const uword in_col, const uword in_slice) const + { + return mem[in_slice*n_elem_slice + in_col*n_rows + in_row]; + } + + + +//! prefix ++ +template +arma_inline +const Cube& +Cube::operator++() + { + Cube_aux::prefix_pp(*this); + return *this; + } + + + +//! postfix ++ (must not return the object by reference) +template +arma_inline +void +Cube::operator++(int) + { + Cube_aux::postfix_pp(*this); + } + + + +//! prefix -- +template +arma_inline +const Cube& +Cube::operator--() + { + Cube_aux::prefix_mm(*this); + return *this; + } + + + +//! postfix -- (must not return the object by reference) +template +arma_inline +void +Cube::operator--(int) + { + Cube_aux::postfix_mm(*this); + } + + + +//! returns true if all of the elements are finite +template +arma_inline +arma_warn_unused +bool +Cube::is_finite() const + { + return arrayops::is_finite( memptr(), n_elem ); + } + + + +//! returns true if the cube has no elements +template +arma_inline +arma_warn_unused +bool +Cube::is_empty() const + { + return (n_elem == 0); + } + + + +//! returns true if the given index is currently in range +template +arma_inline +arma_warn_unused +bool +Cube::in_range(const uword i) const + { + return (i < n_elem); + } + + + +//! returns true if the given start and end indices are currently in range +template +arma_inline +arma_warn_unused +bool +Cube::in_range(const span& x) const + { + arma_extra_debug_sigprint(); + + if(x.whole == true) + { + return true; + } + else + { + const uword a = x.a; + const uword b = x.b; + + return ( (a <= b) && (b < n_elem) ); + } + } + + + +//! returns true if the given location is currently in range +template +arma_inline +arma_warn_unused +bool +Cube::in_range(const uword in_row, const uword in_col, const uword in_slice) const + { + return ( (in_row < n_rows) && (in_col < n_cols) && (in_slice < n_slices) ); + } + + + +template +inline +arma_warn_unused +bool +Cube::in_range(const span& row_span, const span& col_span, const span& slice_span) const + { + arma_extra_debug_sigprint(); + + const uword in_row1 = row_span.a; + const uword in_row2 = row_span.b; + + const uword in_col1 = col_span.a; + const uword in_col2 = col_span.b; + + const uword in_slice1 = slice_span.a; + const uword in_slice2 = slice_span.b; + + + const bool rows_ok = row_span.whole ? true : ( (in_row1 <= in_row2) && (in_row2 < n_rows) ); + const bool cols_ok = col_span.whole ? true : ( (in_col1 <= in_col2) && (in_col2 < n_cols) ); + const bool slices_ok = slice_span.whole ? true : ( (in_slice1 <= in_slice2) && (in_slice2 < n_slices) ); + + + return ( (rows_ok == true) && (cols_ok == true) && (slices_ok == true) ); + } + + + +//! returns a pointer to array of eTs used by the cube +template +arma_inline +arma_warn_unused +eT* +Cube::memptr() + { + return const_cast(mem); + } + + + +//! returns a pointer to array of eTs used by the cube +template +arma_inline +arma_warn_unused +const eT* +Cube::memptr() const + { + return mem; + } + + + +//! returns a pointer to array of eTs used by the specified slice in the cube +template +arma_inline +arma_warn_unused +eT* +Cube::slice_memptr(const uword slice) + { + return const_cast( &mem[ slice*n_elem_slice ] ); + } + + + +//! returns a pointer to array of eTs used by the specified slice in the cube +template +arma_inline +arma_warn_unused +const eT* +Cube::slice_memptr(const uword slice) const + { + return &mem[ slice*n_elem_slice ]; + } + + + +//! returns a pointer to array of eTs used by the specified slice in the cube +template +arma_inline +arma_warn_unused +eT* +Cube::slice_colptr(const uword slice, const uword col) + { + return const_cast( &mem[ slice*n_elem_slice + col*n_rows] ); + } + + + +//! returns a pointer to array of eTs used by the specified slice in the cube +template +arma_inline +arma_warn_unused +const eT* +Cube::slice_colptr(const uword slice, const uword col) const + { + return &mem[ slice*n_elem_slice + col*n_rows ]; + } + + + +//! print contents of the cube (to the cout stream), +//! optionally preceding with a user specified line of text. +//! the precision and cell width are modified. +//! on return, the stream's state are restored to their original values. +template +inline +void +Cube::impl_print(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + ARMA_DEFAULT_OSTREAM << extra_text << '\n'; + } + + arma_ostream::print(ARMA_DEFAULT_OSTREAM, *this, true); + } + + +//! print contents of the cube to a user specified stream, +//! optionally preceding with a user specified line of text. +//! the precision and cell width are modified. +//! on return, the stream's state are restored to their original values. +template +inline +void +Cube::impl_print(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + user_stream << extra_text << '\n'; + } + + arma_ostream::print(user_stream, *this, true); + } + + + +//! print contents of the cube (to the cout stream), +//! optionally preceding with a user specified line of text. +//! the stream's state are used as is and are not modified +//! (i.e. the precision and cell width are not modified). +template +inline +void +Cube::impl_raw_print(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + ARMA_DEFAULT_OSTREAM << extra_text << '\n'; + } + + arma_ostream::print(ARMA_DEFAULT_OSTREAM, *this, false); + } + + + +//! print contents of the cube to a user specified stream, +//! optionally preceding with a user specified line of text. +//! the stream's state are used as is and are not modified. +//! (i.e. the precision and cell width are not modified). +template +inline +void +Cube::impl_raw_print(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + user_stream << extra_text << '\n'; + } + + arma_ostream::print(user_stream, *this, false); + } + + + +//! change the cube to have user specified dimensions (data is not preserved) +template +inline +void +Cube::set_size(const uword in_n_rows, const uword in_n_cols, const uword in_n_slices) + { + arma_extra_debug_sigprint(); + + init_warm(in_n_rows, in_n_cols, in_n_slices); + } + + + +//! change the cube to have user specified dimensions (data is preserved) +template +inline +void +Cube::reshape(const uword in_rows, const uword in_cols, const uword in_slices, const uword dim) + { + arma_extra_debug_sigprint(); + + *this = arma::reshape(*this, in_rows, in_cols, in_slices, dim); + } + + + +//! change the cube to have user specified dimensions (data is preserved) +template +inline +void +Cube::resize(const uword in_rows, const uword in_cols, const uword in_slices) + { + arma_extra_debug_sigprint(); + + *this = arma::resize(*this, in_rows, in_cols, in_slices); + } + + + +//! change the cube (without preserving data) to have the same dimensions as the given cube +template +template +inline +void +Cube::copy_size(const Cube& m) + { + arma_extra_debug_sigprint(); + + init_warm(m.n_rows, m.n_cols, m.n_slices); + } + + + +//! fill the cube with the specified value +template +inline +const Cube& +Cube::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( memptr(), val, n_elem ); + + return *this; + } + + + +template +inline +const Cube& +Cube::zeros() + { + arma_extra_debug_sigprint(); + + return (*this).fill(eT(0)); + } + + + +template +inline +const Cube& +Cube::zeros(const uword in_rows, const uword in_cols, const uword in_slices) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols, in_slices); + + return (*this).fill(eT(0)); + } + + + +template +inline +const Cube& +Cube::ones() + { + arma_extra_debug_sigprint(); + + return (*this).fill(eT(1)); + } + + + +template +inline +const Cube& +Cube::ones(const uword in_rows, const uword in_cols, const uword in_slices) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols, in_slices); + + return (*this).fill(eT(1)); + } + + + +template +inline +const Cube& +Cube::randu() + { + arma_extra_debug_sigprint(); + + const uword N = n_elem; + eT* ptr = memptr(); + + uword i,j; + + for(i=0, j=1; j()); + ptr[j] = eT(eop_aux_randu()); + } + + if(i < N) + { + ptr[i] = eT(eop_aux_randu()); + } + + return *this; + } + + + +template +inline +const Cube& +Cube::randu(const uword in_rows, const uword in_cols, const uword in_slices) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols, in_slices); + + return (*this).randu(); + } + + + +template +inline +const Cube& +Cube::randn() + { + arma_extra_debug_sigprint(); + + const uword N = n_elem; + eT* ptr = memptr(); + + for(uword i=0; i()); + } + + return *this; + } + + + +template +inline +const Cube& +Cube::randn(const uword in_rows, const uword in_cols, const uword in_slices) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols, in_slices); + + return (*this).randn(); + } + + + +template +inline +void +Cube::reset() + { + arma_extra_debug_sigprint(); + + init_warm(0,0,0); + } + + + +template +template +inline +void +Cube::set_real(const BaseCube::pod_type,T1>& X) + { + arma_extra_debug_sigprint(); + + Cube_aux::set_real(*this, X); + } + + + +template +template +inline +void +Cube::set_imag(const BaseCube::pod_type,T1>& X) + { + arma_extra_debug_sigprint(); + + Cube_aux::set_imag(*this, X); + } + + + +template +inline +arma_warn_unused +eT +Cube::min() const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + return op_min::direct_min(memptr(), n_elem); + } + + + +template +inline +arma_warn_unused +eT +Cube::max() const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + return op_max::direct_max(memptr(), n_elem); + } + + + +template +inline +eT +Cube::min(uword& index_of_min_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + return op_min::direct_min(memptr(), n_elem, index_of_min_val); + } + + + +template +inline +eT +Cube::max(uword& index_of_max_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + return op_max::direct_max(memptr(), n_elem, index_of_max_val); + } + + + +template +inline +eT +Cube::min(uword& row_of_min_val, uword& col_of_min_val, uword& slice_of_min_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + uword i; + + eT val = op_min::direct_min(memptr(), n_elem, i); + + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + row_of_min_val = j % n_rows; + col_of_min_val = j / n_rows; + slice_of_min_val = in_slice; + + return val; + } + + + +template +inline +eT +Cube::max(uword& row_of_max_val, uword& col_of_max_val, uword& slice_of_max_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + uword i; + + eT val = op_max::direct_max(memptr(), n_elem, i); + + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + row_of_max_val = j % n_rows; + col_of_max_val = j / n_rows; + slice_of_max_val = in_slice; + + return val; + } + + + +//! save the cube to a file +template +inline +bool +Cube::save(const std::string name, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + bool save_okay; + + switch(type) + { + case raw_ascii: + save_okay = diskio::save_raw_ascii(*this, name); + break; + + case arma_ascii: + save_okay = diskio::save_arma_ascii(*this, name); + break; + + case raw_binary: + save_okay = diskio::save_raw_binary(*this, name); + break; + + case arma_binary: + save_okay = diskio::save_arma_binary(*this, name); + break; + + case ppm_binary: + save_okay = diskio::save_ppm_binary(*this, name); + break; + + default: + arma_warn(print_status, "Cube::save(): unsupported file type"); + save_okay = false; + } + + arma_warn( (print_status && (save_okay == false)), "Cube::save(): couldn't write to ", name); + + return save_okay; + } + + + +//! save the cube to a stream +template +inline +bool +Cube::save(std::ostream& os, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + bool save_okay; + + switch(type) + { + case raw_ascii: + save_okay = diskio::save_raw_ascii(*this, os); + break; + + case arma_ascii: + save_okay = diskio::save_arma_ascii(*this, os); + break; + + case raw_binary: + save_okay = diskio::save_raw_binary(*this, os); + break; + + case arma_binary: + save_okay = diskio::save_arma_binary(*this, os); + break; + + case ppm_binary: + save_okay = diskio::save_ppm_binary(*this, os); + break; + + default: + arma_warn(print_status, "Cube::save(): unsupported file type"); + save_okay = false; + } + + arma_warn( (print_status && (save_okay == false)), "Cube::save(): couldn't write to given stream"); + + return save_okay; + } + + + +//! load a cube from a file +template +inline +bool +Cube::load(const std::string name, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + bool load_okay; + std::string err_msg; + + switch(type) + { + case auto_detect: + load_okay = diskio::load_auto_detect(*this, name, err_msg); + break; + + case raw_ascii: + load_okay = diskio::load_raw_ascii(*this, name, err_msg); + break; + + case arma_ascii: + load_okay = diskio::load_arma_ascii(*this, name, err_msg); + break; + + case raw_binary: + load_okay = diskio::load_raw_binary(*this, name, err_msg); + break; + + case arma_binary: + load_okay = diskio::load_arma_binary(*this, name, err_msg); + break; + + case ppm_binary: + load_okay = diskio::load_ppm_binary(*this, name, err_msg); + break; + + default: + arma_warn(print_status, "Cube::load(): unsupported file type"); + load_okay = false; + } + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "Cube::load(): ", err_msg, name); + } + else + { + arma_warn(true, "Cube::load(): couldn't read ", name); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +//! load a cube from a stream +template +inline +bool +Cube::load(std::istream& is, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + bool load_okay; + std::string err_msg; + + switch(type) + { + case auto_detect: + load_okay = diskio::load_auto_detect(*this, is, err_msg); + break; + + case raw_ascii: + load_okay = diskio::load_raw_ascii(*this, is, err_msg); + break; + + case arma_ascii: + load_okay = diskio::load_arma_ascii(*this, is, err_msg); + break; + + case raw_binary: + load_okay = diskio::load_raw_binary(*this, is, err_msg); + break; + + case arma_binary: + load_okay = diskio::load_arma_binary(*this, is, err_msg); + break; + + case ppm_binary: + load_okay = diskio::load_ppm_binary(*this, is, err_msg); + break; + + default: + arma_warn(print_status, "Cube::load(): unsupported file type"); + load_okay = false; + } + + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "Cube::load(): ", err_msg, "the given stream"); + } + else + { + arma_warn(true, "Cube::load(): couldn't load from the given stream"); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +//! save the cube to a file, without printing any error messages +template +inline +bool +Cube::quiet_save(const std::string name, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(name, type, false); + } + + + +//! save the cube to a stream, without printing any error messages +template +inline +bool +Cube::quiet_save(std::ostream& os, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(os, type, false); + } + + + +//! load a cube from a file, without printing any error messages +template +inline +bool +Cube::quiet_load(const std::string name, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(name, type, false); + } + + + +//! load a cube from a stream, without printing any error messages +template +inline +bool +Cube::quiet_load(std::istream& is, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(is, type, false); + } + + + +template +inline +typename Cube::iterator +Cube::begin() + { + arma_extra_debug_sigprint(); + + return memptr(); + } + + + +template +inline +typename Cube::const_iterator +Cube::begin() const + { + arma_extra_debug_sigprint(); + + return memptr(); + } + + + +template +inline +typename Cube::iterator +Cube::end() + { + arma_extra_debug_sigprint(); + + return memptr() + n_elem; + } + + + +template +inline +typename Cube::const_iterator +Cube::end() const + { + arma_extra_debug_sigprint(); + + return memptr() + n_elem; + } + + + +template +inline +typename Cube::slice_iterator +Cube::begin_slice(const uword slice_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (slice_num >= n_slices), "begin_slice(): index out of bounds"); + + return slice_memptr(slice_num); + } + + + +template +inline +typename Cube::const_slice_iterator +Cube::begin_slice(const uword slice_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (slice_num >= n_slices), "begin_slice(): index out of bounds"); + + return slice_memptr(slice_num); + } + + + +template +inline +typename Cube::slice_iterator +Cube::end_slice(const uword slice_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (slice_num >= n_slices), "end_slice(): index out of bounds"); + + return slice_memptr(slice_num) + n_elem_slice; + } + + + +template +inline +typename Cube::const_slice_iterator +Cube::end_slice(const uword slice_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (slice_num >= n_slices), "end_slice(): index out of bounds"); + + return slice_memptr(slice_num) + n_elem_slice; + } + + + +template +template +arma_inline +void +Cube::fixed::mem_setup() + { + arma_extra_debug_sigprint_this(this); + + if(fixed_n_elem > 0) + { + access::rw(Cube::n_rows) = fixed_n_rows; + access::rw(Cube::n_cols) = fixed_n_cols; + access::rw(Cube::n_elem_slice) = fixed_n_rows * fixed_n_cols; + access::rw(Cube::n_slices) = fixed_n_slices; + access::rw(Cube::n_elem) = fixed_n_elem; + access::rw(Cube::mem_state) = 3; + access::rw(Cube::mat_ptrs) = const_cast< const Mat** >( \ + (fixed_n_slices > Cube_prealloc::mat_ptrs_size) ? mat_ptrs_local_extra : mat_ptrs_local ); + access::rw(Cube::mem) = (fixed_n_elem > Cube_prealloc::mem_n_elem) ? mem_local_extra : mem_local; + + create_mat(); + } + else + { + access::rw(Cube::n_rows) = 0; + access::rw(Cube::n_cols) = 0; + access::rw(Cube::n_elem_slice) = 0; + access::rw(Cube::n_slices) = 0; + access::rw(Cube::n_elem) = 0; + access::rw(Cube::mem_state) = 3; + access::rw(Cube::mat_ptrs) = 0; + access::rw(Cube::mem) = 0; + } + } + + + +//! prefix ++ +template +arma_inline +void +Cube_aux::prefix_pp(Cube& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Cube_aux::prefix_pp(Cube< std::complex >& x) + { + x += T(1); + } + + + +//! postfix ++ +template +arma_inline +void +Cube_aux::postfix_pp(Cube& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Cube_aux::postfix_pp(Cube< std::complex >& x) + { + x += T(1); + } + + + +//! prefix -- +template +arma_inline +void +Cube_aux::prefix_mm(Cube& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Cube_aux::prefix_mm(Cube< std::complex >& x) + { + x -= T(1); + } + + + +//! postfix -- +template +arma_inline +void +Cube_aux::postfix_mm(Cube& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Cube_aux::postfix_mm(Cube< std::complex >& x) + { + x -= T(1); + } + + + +template +inline +void +Cube_aux::set_real(Cube& out, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(X.get_ref()); + const Cube& A = tmp.M; + + arma_debug_assert_same_size( out, A, "Cube::set_real()" ); + + out = A; + } + + + +template +inline +void +Cube_aux::set_imag(Cube& out, const BaseCube& X) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +Cube_aux::set_real(Cube< std::complex >& out, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename ProxyCube::ea_type ea_type; + + const ProxyCube A(X.get_ref()); + + arma_debug_assert_same_size + ( + out.n_rows, out.n_cols, out.n_slices, + A.get_n_rows(), A.get_n_cols(), A.get_n_slices(), + "Cube::set_real()" + ); + + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + ea_type PA = A.get_ea(); + + for(uword i=0; i( PA[i], out_mem[i].imag() ); + } + } + + + +template +inline +void +Cube_aux::set_imag(Cube< std::complex >& out, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename ProxyCube::ea_type ea_type; + + const ProxyCube A(X.get_ref()); + + arma_debug_assert_same_size + ( + out.n_rows, out.n_cols, out.n_slices, + A.get_n_rows(), A.get_n_cols(), A.get_n_slices(), + "Cube::set_imag()" + ); + + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + ea_type PA = A.get_ea(); + + for(uword i=0; i( out_mem[i].real(), PA[i] ); + } + } + + + +#ifdef ARMA_EXTRA_CUBE_MEAT + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_CUBE_MEAT) +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/GenCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/GenCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,50 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup GenCube +//! @{ + + +//! support class for generator functions (eg. zeros, randu, randn, ...) +template +class GenCube : public BaseCube > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + static const bool prefer_at_accessor = false; + + arma_aligned const uword n_rows; + arma_aligned const uword n_cols; + arma_aligned const uword n_slices; + + arma_inline GenCube(const uword in_n_rows, const uword in_n_cols, const uword in_n_slices); + arma_inline ~GenCube(); + + arma_inline static eT generate(); + + arma_inline eT operator[] (const uword i) const; + arma_inline eT at (const uword row, const uword col, const uword slice) const; + + inline void apply (Cube& out) const; + inline void apply_inplace_plus (Cube& out) const; + inline void apply_inplace_minus(Cube& out) const; + inline void apply_inplace_schur(Cube& out) const; + inline void apply_inplace_div (Cube& out) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/GenCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/GenCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,224 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Gen +//! @{ + + + +template +arma_inline +GenCube::GenCube(const uword in_n_rows, const uword in_n_cols, const uword in_n_slices) + : n_rows (in_n_rows ) + , n_cols (in_n_cols ) + , n_slices(in_n_slices) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +GenCube::~GenCube() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +eT +GenCube::generate() + { + if(is_same_type::value == true) { return eT(1); } + else if(is_same_type::value == true) { return eT(0); } + else if(is_same_type::value == true) { return eT(eop_aux_randu()); } + else if(is_same_type::value == true) { return eT(eop_aux_randn()); } + else { return eT(); } + } + + + +template +arma_inline +eT +GenCube::operator[](const uword) const + { + return GenCube::generate(); + } + + + +template +arma_inline +eT +GenCube::at(const uword, const uword, const uword) const + { + return GenCube::generate(); + } + + + +template +inline +void +GenCube::apply(Cube& out) const + { + arma_extra_debug_sigprint(); + + // NOTE: we're assuming that the cube has already been set to the correct size; + // this is done by either the Cube contructor or operator=() + + if(is_same_type::value == true) { out.ones(); } + else if(is_same_type::value == true) { out.zeros(); } + else if(is_same_type::value == true) { out.randu(); } + else if(is_same_type::value == true) { out.randn(); } + } + + + +template +inline +void +GenCube::apply_inplace_plus(Cube& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "addition"); + + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + uword i,j; + + for(i=0, j=1; j::generate(); + const eT tmp_j = GenCube::generate(); + + out_mem[i] += tmp_i; + out_mem[j] += tmp_j; + } + + if(i < n_elem) + { + out_mem[i] += GenCube::generate(); + } + } + + + + +template +inline +void +GenCube::apply_inplace_minus(Cube& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "subtraction"); + + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + uword i,j; + + for(i=0, j=1; j::generate(); + const eT tmp_j = GenCube::generate(); + + out_mem[i] -= tmp_i; + out_mem[j] -= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] -= GenCube::generate(); + } + } + + + + +template +inline +void +GenCube::apply_inplace_schur(Cube& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise multiplication"); + + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + uword i,j; + + for(i=0, j=1; j::generate(); + const eT tmp_j = GenCube::generate(); + + out_mem[i] *= tmp_i; + out_mem[j] *= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] *= GenCube::generate(); + } + } + + + + +template +inline +void +GenCube::apply_inplace_div(Cube& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise division"); + + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + uword i,j; + + for(i=0, j=1; j::generate(); + const eT tmp_j = GenCube::generate(); + + out_mem[i] /= tmp_i; + out_mem[j] /= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] /= GenCube::generate(); + } + } + + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Gen_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Gen_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,49 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Gen +//! @{ + + +//! support class for generator functions (eg. zeros, randu, randn, ...) +template +class Gen : public Base > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + static const bool prefer_at_accessor = (is_same_type::value) ? true : false; + + arma_aligned const uword n_rows; + arma_aligned const uword n_cols; + + arma_inline Gen(const uword in_n_rows, const uword in_n_cols); + arma_inline ~Gen(); + + arma_inline static eT generate(); + + arma_inline eT operator[] (const uword i) const; + arma_inline eT at (const uword row, const uword col) const; + + inline void apply (Mat& out) const; + inline void apply_inplace_plus (Mat& out) const; + inline void apply_inplace_minus(Mat& out) const; + inline void apply_inplace_schur(Mat& out) const; + inline void apply_inplace_div (Mat& out) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Gen_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Gen_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,294 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Gen +//! @{ + + + +template +arma_inline +Gen::Gen(const uword in_n_rows, const uword in_n_cols) + : n_rows(in_n_rows) + , n_cols(in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +Gen::~Gen() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +eT +Gen::generate() + { + if(is_same_type::value == true) { return eT(1); } + else if(is_same_type::value == true) { return eT(0); } + else if(is_same_type::value == true) { return eT(eop_aux_randu()); } + else if(is_same_type::value == true) { return eT(eop_aux_randn()); } + else { return eT(); } + } + + + +template +arma_inline +eT +Gen::operator[](const uword i) const + { + if(is_same_type::value == true) + { + return ((i % n_rows) == (i / n_rows)) ? eT(1) : eT(0); + } + else + { + return Gen::generate(); + } + } + + + +template +arma_inline +eT +Gen::at(const uword row, const uword col) const + { + if(is_same_type::value == true) + { + return (row == col) ? eT(1) : eT(0); + } + else + { + return Gen::generate(); + } + } + + + +template +inline +void +Gen::apply(Mat& out) const + { + arma_extra_debug_sigprint(); + + // NOTE: we're assuming that the matrix has already been set to the correct size; + // this is done by either the Mat contructor or operator=() + + if(is_same_type::value == true) { out.eye(); } + else if(is_same_type::value == true) { out.ones(); } + else if(is_same_type::value == true) { out.zeros(); } + else if(is_same_type::value == true) { out.randu(); } + else if(is_same_type::value == true) { out.randn(); } + } + + + +template +inline +void +Gen::apply_inplace_plus(Mat& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "addition"); + + + if(is_same_type::value == true) + { + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i::generate(); + const eT tmp_j = Gen::generate(); + + out_mem[i] += tmp_i; + out_mem[j] += tmp_j; + } + + if(i < n_elem) + { + out_mem[i] += Gen::generate(); + } + } + + } + + + + +template +inline +void +Gen::apply_inplace_minus(Mat& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "subtraction"); + + + if(is_same_type::value == true) + { + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i::generate(); + const eT tmp_j = Gen::generate(); + + out_mem[i] -= tmp_i; + out_mem[j] -= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] -= Gen::generate(); + } + } + + } + + + + +template +inline +void +Gen::apply_inplace_schur(Mat& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "element-wise multiplication"); + + + if(is_same_type::value == true) + { + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i::generate(); + const eT tmp_j = Gen::generate(); + + out_mem[i] *= tmp_i; + out_mem[j] *= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] *= Gen::generate(); + } + } + + } + + + + +template +inline +void +Gen::apply_inplace_div(Mat& out) const + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "element-wise division"); + + + if(is_same_type::value == true) + { + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i::generate(); + const eT tmp_j = Gen::generate(); + + out_mem[i] /= tmp_i; + out_mem[j] /= tmp_j; + } + + if(i < n_elem) + { + out_mem[i] /= Gen::generate(); + } + } + + } + + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/GlueCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/GlueCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup GlueCube +//! @{ + + + +//! analog of the Glue class, intended for Cube objects +template +class GlueCube : public BaseCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + arma_inline GlueCube(const BaseCube& in_A, const BaseCube& in_B); + arma_inline ~GlueCube(); + + const T1& A; //!< first operand + const T2& B; //!< second operand + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/GlueCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/GlueCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,39 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup GlueCube +//! @{ + + + +template +inline +GlueCube::GlueCube(const BaseCube& in_A, const BaseCube& in_B) + : A(in_A.get_ref()) + , B(in_B.get_ref()) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +GlueCube::~GlueCube() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Glue_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Glue_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Glue +//! @{ + + + +//! Class for storing data required for delayed binary operations, +//! such as the operands (e.g. two matrices) and the binary operator (e.g. addition). +//! The operands are stored as references (which can be optimised away), +//! while the operator is "stored" through the template definition (glue_type). +//! The operands can be 'Mat', 'Row', 'Col', 'Op', and 'Glue'. +//! Note that as 'Glue' can be one of the operands, more than two matrices can be stored. +//! +//! For example, we could have: Glue +//! +//! Another example is: Glue< Op, Op, glue_times > + + + +template +class Glue : public Base > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + arma_inline Glue(const T1& in_A, const T2& in_B); + arma_inline Glue(const T1& in_A, const T2& in_B, const uword in_aux_uword); + arma_inline ~Glue(); + + const T1& A; //!< first operand + const T2& B; //!< second operand + uword aux_uword; //!< storage of auxiliary data, uword format + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Glue_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Glue_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Glue +//! @{ + + + +template +inline +Glue::Glue(const T1& in_A, const T2& in_B) + : A(in_A) + , B(in_B) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Glue::Glue(const T1& in_A, const T2& in_B, const uword in_aux_uword) + : A(in_A) + , B(in_B) + , aux_uword(in_aux_uword) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Glue::~Glue() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Mat_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Mat_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,575 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Mat +//! @{ + + + +//! Dense matrix class + +template +class Mat : public Base< eT, Mat > + { + public: + + typedef eT elem_type; //!< the type of elements stored in the matrix + typedef typename get_pod_type::result pod_type; //!< if eT is non-complex, pod_type is same as eT. otherwise, pod_type is the underlying type used by std::complex + + const uword n_rows; //!< number of rows in the matrix (read-only) + const uword n_cols; //!< number of columns in the matrix (read-only) + const uword n_elem; //!< number of elements in the matrix (read-only) + const uhword vec_state; //!< 0: matrix layout; 1: column vector layout; 2: row vector layout + const uhword mem_state; + + // mem_state = 0: normal matrix that can be resized; + // mem_state = 1: use auxiliary memory until change in the number of elements is requested; + // mem_state = 2: use auxiliary memory and don't allow the number of elements to be changed; + // mem_state = 3: fixed size (e.g. via template based size specification). + + arma_aligned const eT* const mem; //!< pointer to the memory used by the matrix (memory is read-only) + + protected: + arma_aligned eT mem_local[ arma_config::mat_prealloc ]; + + + public: + + inline ~Mat(); + inline Mat(); + + inline Mat(const uword in_rows, const uword in_cols); + + inline Mat(const char* text); + inline const Mat& operator=(const char* text); + + inline Mat(const std::string& text); + inline const Mat& operator=(const std::string& text); + + #if defined(ARMA_USE_CXX11) + inline Mat(const std::initializer_list& list); + inline const Mat& operator=(const std::initializer_list& list); + #endif + + inline Mat( eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const bool copy_aux_mem = true, const bool strict = true); + inline Mat(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols); + + arma_inline const Mat& operator=(const eT val); + arma_inline const Mat& operator+=(const eT val); + arma_inline const Mat& operator-=(const eT val); + arma_inline const Mat& operator*=(const eT val); + arma_inline const Mat& operator/=(const eT val); + + inline Mat(const Mat& m); + inline const Mat& operator=(const Mat& m); + inline const Mat& operator+=(const Mat& m); + inline const Mat& operator-=(const Mat& m); + inline const Mat& operator*=(const Mat& m); + inline const Mat& operator%=(const Mat& m); + inline const Mat& operator/=(const Mat& m); + + template inline Mat(const BaseCube& X); + template inline const Mat& operator=(const BaseCube& X); + template inline const Mat& operator+=(const BaseCube& X); + template inline const Mat& operator-=(const BaseCube& X); + template inline const Mat& operator*=(const BaseCube& X); + template inline const Mat& operator%=(const BaseCube& X); + template inline const Mat& operator/=(const BaseCube& X); + + template + inline explicit Mat(const Base& A, const Base& B); + + inline Mat(const subview& X); + inline const Mat& operator=(const subview& X); + inline const Mat& operator+=(const subview& X); + inline const Mat& operator-=(const subview& X); + inline const Mat& operator*=(const subview& X); + inline const Mat& operator%=(const subview& X); + inline const Mat& operator/=(const subview& X); + + //inline explicit Mat(const subview_cube& X); + inline Mat(const subview_cube& X); + inline const Mat& operator=(const subview_cube& X); + inline const Mat& operator+=(const subview_cube& X); + inline const Mat& operator-=(const subview_cube& X); + inline const Mat& operator*=(const subview_cube& X); + inline const Mat& operator%=(const subview_cube& X); + inline const Mat& operator/=(const subview_cube& X); + + //inline explicit Mat(const diagview& X); + inline Mat(const diagview& X); + inline const Mat& operator=(const diagview& X); + inline const Mat& operator+=(const diagview& X); + inline const Mat& operator-=(const diagview& X); + inline const Mat& operator*=(const diagview& X); + inline const Mat& operator%=(const diagview& X); + inline const Mat& operator/=(const diagview& X); + + template inline Mat(const subview_elem1& X); + template inline const Mat& operator= (const subview_elem1& X); + template inline const Mat& operator+=(const subview_elem1& X); + template inline const Mat& operator-=(const subview_elem1& X); + template inline const Mat& operator*=(const subview_elem1& X); + template inline const Mat& operator%=(const subview_elem1& X); + template inline const Mat& operator/=(const subview_elem1& X); + + + inline mat_injector operator<<(const eT val); + inline mat_injector operator<<(const injector_end_of_row& x); + + + arma_inline subview_row row(const uword row_num); + arma_inline const subview_row row(const uword row_num) const; + + inline subview_row operator()(const uword row_num, const span& col_span); + inline const subview_row operator()(const uword row_num, const span& col_span) const; + + + arma_inline subview_col col(const uword col_num); + arma_inline const subview_col col(const uword col_num) const; + + inline subview_col operator()(const span& row_span, const uword col_num); + inline const subview_col operator()(const span& row_span, const uword col_num) const; + + inline Col unsafe_col(const uword col_num); + inline const Col unsafe_col(const uword col_num) const; + + + arma_inline subview rows(const uword in_row1, const uword in_row2); + arma_inline const subview rows(const uword in_row1, const uword in_row2) const; + + arma_inline subview cols(const uword in_col1, const uword in_col2); + arma_inline const subview cols(const uword in_col1, const uword in_col2) const; + + arma_inline subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2); + arma_inline const subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const; + + + inline subview submat (const span& row_span, const span& col_span); + inline const subview submat (const span& row_span, const span& col_span) const; + + inline subview operator()(const span& row_span, const span& col_span); + inline const subview operator()(const span& row_span, const span& col_span) const; + + + template arma_inline subview_elem1 elem(const Base& a); + template arma_inline const subview_elem1 elem(const Base& a) const; + + // template arma_inline subview_elem2 submat(const Base& a, const Base& b); + // template arma_inline const subview_elem2 submat(const Base& a, const Base& b) const; + + + arma_inline diagview diag(const sword in_id = 0); + arma_inline const diagview diag(const sword in_id = 0) const; + + + inline void swap_rows(const uword in_row1, const uword in_row2); + inline void swap_cols(const uword in_col1, const uword in_col2); + + inline void shed_row(const uword row_num); + inline void shed_col(const uword col_num); + + inline void shed_rows(const uword in_row1, const uword in_row2); + inline void shed_cols(const uword in_col1, const uword in_col2); + + inline void insert_rows(const uword row_num, const uword N, const bool set_to_zero = true); + inline void insert_cols(const uword col_num, const uword N, const bool set_to_zero = true); + + template inline void insert_rows(const uword row_num, const Base& X); + template inline void insert_cols(const uword col_num, const Base& X); + + + template inline Mat(const Gen& X); + template inline const Mat& operator=(const Gen& X); + template inline const Mat& operator+=(const Gen& X); + template inline const Mat& operator-=(const Gen& X); + template inline const Mat& operator*=(const Gen& X); + template inline const Mat& operator%=(const Gen& X); + template inline const Mat& operator/=(const Gen& X); + + template inline Mat(const Op& X); + template inline const Mat& operator=(const Op& X); + template inline const Mat& operator+=(const Op& X); + template inline const Mat& operator-=(const Op& X); + template inline const Mat& operator*=(const Op& X); + template inline const Mat& operator%=(const Op& X); + template inline const Mat& operator/=(const Op& X); + + template inline Mat(const eOp& X); + template inline const Mat& operator=(const eOp& X); + template inline const Mat& operator+=(const eOp& X); + template inline const Mat& operator-=(const eOp& X); + template inline const Mat& operator*=(const eOp& X); + template inline const Mat& operator%=(const eOp& X); + template inline const Mat& operator/=(const eOp& X); + + template inline Mat(const mtOp& X); + template inline const Mat& operator=(const mtOp& X); + template inline const Mat& operator+=(const mtOp& X); + template inline const Mat& operator-=(const mtOp& X); + template inline const Mat& operator*=(const mtOp& X); + template inline const Mat& operator%=(const mtOp& X); + template inline const Mat& operator/=(const mtOp& X); + + template inline Mat(const Glue& X); + template inline const Mat& operator=(const Glue& X); + template inline const Mat& operator+=(const Glue& X); + template inline const Mat& operator-=(const Glue& X); + template inline const Mat& operator*=(const Glue& X); + template inline const Mat& operator%=(const Glue& X); + template inline const Mat& operator/=(const Glue& X); + + template inline const Mat& operator+=(const Glue& X); + template inline const Mat& operator-=(const Glue& X); + + template inline Mat(const eGlue& X); + template inline const Mat& operator=(const eGlue& X); + template inline const Mat& operator+=(const eGlue& X); + template inline const Mat& operator-=(const eGlue& X); + template inline const Mat& operator*=(const eGlue& X); + template inline const Mat& operator%=(const eGlue& X); + template inline const Mat& operator/=(const eGlue& X); + + template inline Mat(const mtGlue& X); + template inline const Mat& operator=(const mtGlue& X); + template inline const Mat& operator+=(const mtGlue& X); + template inline const Mat& operator-=(const mtGlue& X); + template inline const Mat& operator*=(const mtGlue& X); + template inline const Mat& operator%=(const mtGlue& X); + template inline const Mat& operator/=(const mtGlue& X); + + + arma_inline arma_warn_unused eT& operator[] (const uword i); + arma_inline arma_warn_unused eT operator[] (const uword i) const; + arma_inline arma_warn_unused eT& at (const uword i); + arma_inline arma_warn_unused eT at (const uword i) const; + arma_inline arma_warn_unused eT& operator() (const uword i); + arma_inline arma_warn_unused eT operator() (const uword i) const; + + arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT at (const uword in_row, const uword in_col) const; + arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; + + arma_inline const Mat& operator++(); + arma_inline void operator++(int); + + arma_inline const Mat& operator--(); + arma_inline void operator--(int); + + arma_inline arma_warn_unused bool is_empty() const; + arma_inline arma_warn_unused bool is_vec() const; + arma_inline arma_warn_unused bool is_rowvec() const; + arma_inline arma_warn_unused bool is_colvec() const; + arma_inline arma_warn_unused bool is_square() const; + inline arma_warn_unused bool is_finite() const; + + arma_inline arma_warn_unused bool in_range(const uword i) const; + arma_inline arma_warn_unused bool in_range(const span& x) const; + + arma_inline arma_warn_unused bool in_range(const uword in_row, const uword in_col) const; + arma_inline arma_warn_unused bool in_range(const span& row_span, const uword in_col) const; + arma_inline arma_warn_unused bool in_range(const uword in_row, const span& col_span) const; + arma_inline arma_warn_unused bool in_range(const span& row_span, const span& col_span) const; + + arma_inline arma_warn_unused eT* colptr(const uword in_col); + arma_inline arma_warn_unused const eT* colptr(const uword in_col) const; + + arma_inline arma_warn_unused eT* memptr(); + arma_inline arma_warn_unused const eT* memptr() const; + + + inline void impl_print(const std::string& extra_text) const; + inline void impl_print(std::ostream& user_stream, const std::string& extra_text) const; + + inline void impl_print_trans(const std::string& extra_text) const; + inline void impl_print_trans(std::ostream& user_stream, const std::string& extra_text) const; + + inline void impl_raw_print(const std::string& extra_text) const; + inline void impl_raw_print(std::ostream& user_stream, const std::string& extra_text) const; + + inline void impl_raw_print_trans(const std::string& extra_text) const; + inline void impl_raw_print_trans(std::ostream& user_stream, const std::string& extra_text) const; + + + template + inline void copy_size(const Mat& m); + + inline void set_size(const uword in_elem); + inline void set_size(const uword in_rows, const uword in_cols); + + inline void resize(const uword in_elem); + inline void resize(const uword in_rows, const uword in_cols); + inline void reshape(const uword in_rows, const uword in_cols, const uword dim = 0); + + + arma_hot inline const Mat& fill(const eT val); + + inline const Mat& zeros(); + inline const Mat& zeros(const uword in_elem); + inline const Mat& zeros(const uword in_rows, const uword in_cols); + + inline const Mat& ones(); + inline const Mat& ones(const uword in_elem); + inline const Mat& ones(const uword in_rows, const uword in_cols); + + inline const Mat& randu(); + inline const Mat& randu(const uword in_elem); + inline const Mat& randu(const uword in_rows, const uword in_cols); + + inline const Mat& randn(); + inline const Mat& randn(const uword in_elem); + inline const Mat& randn(const uword in_rows, const uword in_cols); + + inline const Mat& eye(); + inline const Mat& eye(const uword in_rows, const uword in_cols); + + inline void reset(); + + + template inline void set_real(const Base& X); + template inline void set_imag(const Base& X); + + + inline arma_warn_unused eT min() const; + inline arma_warn_unused eT max() const; + + inline eT min(uword& index_of_min_val) const; + inline eT max(uword& index_of_max_val) const; + + inline eT min(uword& row_of_min_val, uword& col_of_min_val) const; + inline eT max(uword& row_of_max_val, uword& col_of_max_val) const; + + + inline bool save(const std::string name, const file_type type = arma_binary, const bool print_status = true) const; + inline bool save( std::ostream& os, const file_type type = arma_binary, const bool print_status = true) const; + + inline bool load(const std::string name, const file_type type = auto_detect, const bool print_status = true); + inline bool load( std::istream& is, const file_type type = auto_detect, const bool print_status = true); + + inline bool quiet_save(const std::string name, const file_type type = arma_binary) const; + inline bool quiet_save( std::ostream& os, const file_type type = arma_binary) const; + + inline bool quiet_load(const std::string name, const file_type type = auto_detect); + inline bool quiet_load( std::istream& is, const file_type type = auto_detect); + + + // for container-like functionality + + typedef eT value_type; + typedef uword size_type; + + typedef eT* iterator; + typedef const eT* const_iterator; + + typedef eT* col_iterator; + typedef const eT* const_col_iterator; + + class row_iterator + { + public: + + inline row_iterator(Mat& in_M, const uword in_row); + + inline eT& operator* (); + + inline row_iterator& operator++(); + inline void operator++(int); + + inline row_iterator& operator--(); + inline void operator--(int); + + inline bool operator!=(const row_iterator& X) const; + inline bool operator==(const row_iterator& X) const; + + arma_aligned Mat& M; + arma_aligned uword row; + arma_aligned uword col; + }; + + + class const_row_iterator + { + public: + + const_row_iterator(const Mat& in_M, const uword in_row); + const_row_iterator(const row_iterator& X); + + inline eT operator*() const; + + inline const_row_iterator& operator++(); + inline void operator++(int); + + inline const_row_iterator& operator--(); + inline void operator--(int); + + inline bool operator!=(const const_row_iterator& X) const; + inline bool operator==(const const_row_iterator& X) const; + + arma_aligned const Mat& M; + arma_aligned uword row; + arma_aligned uword col; + }; + + inline iterator begin(); + inline const_iterator begin() const; + + inline iterator end(); + inline const_iterator end() const; + + inline col_iterator begin_col(const uword col_num); + inline const_col_iterator begin_col(const uword col_num) const; + + inline col_iterator end_col (const uword col_num); + inline const_col_iterator end_col (const uword col_num) const; + + inline row_iterator begin_row(const uword row_num); + inline const_row_iterator begin_row(const uword row_num) const; + + inline row_iterator end_row (const uword row_num); + inline const_row_iterator end_row (const uword row_num) const; + + inline void clear(); + inline bool empty() const; + inline uword size() const; + + template + class fixed : public Mat + { + private: + + static const uword fixed_n_elem = fixed_n_rows * fixed_n_cols; + static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc); + + arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; + + arma_inline void mem_setup(); + + + public: + + static const uword n_rows = fixed_n_rows; + static const uword n_cols = fixed_n_cols; + static const uword n_elem = fixed_n_elem; + + + arma_inline fixed(); + arma_inline fixed(const fixed& X); + + template inline fixed(const Base& A); + template inline fixed(const Base& A, const Base& B); + + inline fixed( eT* aux_mem, const bool copy_aux_mem = true); + inline fixed(const eT* aux_mem); + + inline fixed(const char* text); + inline fixed(const std::string& text); + + // TODO: handling of initializer_list ? + + template inline const Mat& operator=(const Base& A); + + inline const Mat& operator=(const eT val); + inline const Mat& operator=(const char* text); + inline const Mat& operator=(const std::string& text); + + + inline subview_row operator()(const uword row_num, const span& col_span); + inline const subview_row operator()(const uword row_num, const span& col_span) const; + + inline subview_col operator()(const span& row_span, const uword col_num); + inline const subview_col operator()(const span& row_span, const uword col_num) const; + + inline subview operator()(const span& row_span, const span& col_span); + inline const subview operator()(const span& row_span, const span& col_span) const; + + + arma_inline arma_warn_unused eT& operator[] (const uword i); + arma_inline arma_warn_unused eT operator[] (const uword i) const; + arma_inline arma_warn_unused eT& at (const uword i); + arma_inline arma_warn_unused eT at (const uword i) const; + arma_inline arma_warn_unused eT& operator() (const uword i); + arma_inline arma_warn_unused eT operator() (const uword i) const; + + arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT at (const uword in_row, const uword in_col) const; + arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; + + + arma_hot inline const Mat& fill(const eT val); + arma_hot inline const Mat& zeros(); + arma_hot inline const Mat& ones(); + }; + + + protected: + + inline void init_cold(); + inline void init_warm(uword in_rows, uword in_cols); + + inline void init(const std::string& text); + + #if defined(ARMA_USE_CXX11) + inline void init(const std::initializer_list& list); + #endif + + template + inline void init(const Base& A, const Base& B); + + inline void steal_mem(Mat& X); + + inline Mat(const char junk, const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols); + + friend class Cube; + friend class glue_join; + friend class op_strans; + friend class op_htrans; + friend class op_resize; + + + public: + + #ifdef ARMA_EXTRA_MAT_PROTO + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_MAT_PROTO) + #endif + }; + + + +class Mat_aux + { + public: + + template arma_inline static void prefix_pp(Mat& x); + template arma_inline static void prefix_pp(Mat< std::complex >& x); + + template arma_inline static void postfix_pp(Mat& x); + template arma_inline static void postfix_pp(Mat< std::complex >& x); + + template arma_inline static void prefix_mm(Mat& x); + template arma_inline static void prefix_mm(Mat< std::complex >& x); + + template arma_inline static void postfix_mm(Mat& x); + template arma_inline static void postfix_mm(Mat< std::complex >& x); + + template inline static void set_real(Mat& out, const Base& X); + template inline static void set_real(Mat< std::complex >& out, const Base< T,T1>& X); + + template inline static void set_imag(Mat& out, const Base& X); + template inline static void set_imag(Mat< std::complex >& out, const Base< T,T1>& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Mat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Mat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,6096 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Mat +//! @{ + + +template +inline +Mat::~Mat() + { + arma_extra_debug_sigprint_this(this); + + if(mem_state == 0) + { + if(n_elem > arma_config::mat_prealloc) + { + #if defined(ARMA_USE_TBB_ALLOC) + scalable_free((void *)(mem)); + #else + delete [] mem; + #endif + } + } + + if(arma_config::debug == true) + { + // try to expose buggy user code that accesses deleted objects + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + access::rw(n_elem) = 0; + access::rw(mem) = 0; + } + + arma_type_check(( is_supported_elem_type::value == false )); + } + + + +template +inline +Mat::Mat() + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + } + + + +//! construct the matrix to have user specified dimensions +template +inline +Mat::Mat(const uword in_n_rows, const uword in_n_cols) + : n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem(in_n_rows*in_n_cols) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + } + + + +template +inline +void +Mat::init_cold() + { + arma_extra_debug_sigprint( arma_boost::format("n_rows = %d, n_cols = %d") % n_rows % n_cols ); + + // ensure that n_elem can hold the result of (n_rows * n_cols) + + arma_debug_check + ( + ( + ( (n_rows > ARMA_MAX_UHWORD) || (n_cols > ARMA_MAX_UHWORD) ) + ? ( (float(n_rows) * float(n_cols)) > float(ARMA_MAX_UWORD) ) + : false + ), + "Mat::init(): requested size is too large" + ); + + if(n_elem <= arma_config::mat_prealloc) + { + access::rw(mem) = mem_local; + } + else + { + arma_extra_debug_print("Mat::init(): allocating memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + access::rw(mem) = (eT *) scalable_malloc(sizeof(eT)*n_elem); + #else + access::rw(mem) = new(std::nothrow) eT[n_elem]; + #endif + + arma_check_bad_alloc( (mem == 0), "Mat::init(): out of memory" ); + } + } + + + +//! internal matrix construction; if the requested size is small enough, memory from the stack is used. otherwise memory is allocated via 'new' +template +inline +void +Mat::init_warm(uword in_n_rows, uword in_n_cols) + { + arma_extra_debug_sigprint( arma_boost::format("in_n_rows = %d, in_n_cols = %d") % in_n_rows % in_n_cols ); + + if( (n_rows == in_n_rows) && (n_cols == in_n_cols) ) + { + return; + } + + bool err_state = false; + char* err_msg = 0; + + const uhword t_vec_state = vec_state; + const uhword t_mem_state = mem_state; + + arma_debug_set_error + ( + err_state, + err_msg, + (t_mem_state == 3), + "Mat::init(): size is fixed and hence cannot be changed" + ); + + if(t_vec_state > 0) + { + if( (in_n_rows == 0) && (in_n_cols == 0) ) + { + if(t_vec_state == 1) + { + in_n_cols = 1; + } + else + if(t_vec_state == 2) + { + in_n_rows = 1; + } + } + else + { + arma_debug_set_error + ( + err_state, + err_msg, + ( ((t_vec_state == 1) && (in_n_cols != 1)) || ((t_vec_state == 2) && (in_n_rows != 1)) ), + "Mat::init(): object is a vector; requested size is not compatible" + ); + } + } + + // ensure that n_elem can hold the result of (n_rows * n_cols) + + arma_debug_set_error + ( + err_state, + err_msg, + ( + ( (in_n_rows > ARMA_MAX_UHWORD) || (in_n_cols > ARMA_MAX_UHWORD) ) + ? ( (float(in_n_rows) * float(in_n_cols)) > float(ARMA_MAX_UWORD) ) + : false + ), + "Mat::init(): requested size is too large" + ); + + arma_debug_check(err_state, err_msg); + + const uword old_n_elem = n_elem; + const uword new_n_elem = in_n_rows * in_n_cols; + + if(old_n_elem == new_n_elem) + { + arma_extra_debug_print("Mat::init(): reusing memory"); + + access::rw(n_rows) = in_n_rows; + access::rw(n_cols) = in_n_cols; + } + else + { + arma_debug_check + ( + (t_mem_state == 2), + "Mat::init(): mismatch between size of auxiliary memory and requested size" + ); + + if(t_mem_state == 0) + { + if(old_n_elem > arma_config::mat_prealloc) + { + arma_extra_debug_print("Mat::init(): freeing memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + scalable_free((void *)(mem)); + #else + delete [] mem; + #endif + } + } + + + if(new_n_elem <= arma_config::mat_prealloc) + { + access::rw(mem) = mem_local; + } + else + { + arma_extra_debug_print("Mat::init(): allocating memory"); + + #if defined(ARMA_USE_TBB_ALLOC) + access::rw(mem) = (eT *) scalable_malloc(sizeof(eT)*new_n_elem); + #else + access::rw(mem) = new(std::nothrow) eT[new_n_elem]; + #endif + + arma_check_bad_alloc( (mem == 0), "Mat::init(): out of memory" ); + } + + access::rw(n_rows) = in_n_rows; + access::rw(n_cols) = in_n_cols; + access::rw(n_elem) = new_n_elem; + access::rw(mem_state) = 0; + } + } + + + +//! create the matrix from a textual description +template +inline +Mat::Mat(const char* text) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init( std::string(text) ); + } + + + +//! create the matrix from a textual description +template +inline +const Mat& +Mat::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + init( std::string(text) ); + return *this; + } + + + +//! create the matrix from a textual description +template +inline +Mat::Mat(const std::string& text) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init(text); + } + + + +//! create the matrix from a textual description +template +inline +const Mat& +Mat::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + init(text); + return *this; + } + + + +//! internal function to create the matrix from a textual description +template +inline +void +Mat::init(const std::string& text) + { + arma_extra_debug_sigprint(); + + // + // work out the size + + uword t_n_rows = 0; + uword t_n_cols = 0; + + bool t_n_cols_found = false; + + std::string token; + + std::string::size_type line_start = 0; + std::string::size_type line_end = 0; + + while( line_start < text.length() ) + { + + line_end = text.find(';', line_start); + + if(line_end == std::string::npos) + line_end = text.length()-1; + + std::string::size_type line_len = line_end - line_start + 1; + std::stringstream line_stream( text.substr(line_start,line_len) ); + + + uword line_n_cols = 0; + while(line_stream >> token) + { + ++line_n_cols; + } + + + if(line_n_cols > 0) + { + if(t_n_cols_found == false) + { + t_n_cols = line_n_cols; + t_n_cols_found = true; + } + else + arma_check( (line_n_cols != t_n_cols), "Mat::init(): inconsistent number of columns in given string"); + + ++t_n_rows; + } + line_start = line_end+1; + + } + + Mat& x = *this; + x.set_size(t_n_rows, t_n_cols); + + line_start = 0; + line_end = 0; + + uword row = 0; + + while( line_start < text.length() ) + { + + line_end = text.find(';', line_start); + + if(line_end == std::string::npos) + line_end = text.length()-1; + + std::string::size_type line_len = line_end - line_start + 1; + std::stringstream line_stream( text.substr(line_start,line_len) ); + +// uword col = 0; +// while(line_stream >> token) +// { +// x.at(row,col) = strtod(token.c_str(), 0); +// ++col; +// } + + uword col = 0; + eT val; + while(line_stream >> val) + { + x.at(row,col) = val; + ++col; + } + + ++row; + line_start = line_end+1; + } + + } + + + +#if defined(ARMA_USE_CXX11) + +template +inline +Mat::Mat(const std::initializer_list& list) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init(list); + } + + + +template +inline +const Mat& +Mat::operator=(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + init(list); + + return *this; + } + +#endif + + + +//! Set the matrix to be equal to the specified scalar. +//! NOTE: the size of the matrix will be 1x1 +template +arma_inline +const Mat& +Mat::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + init_warm(1,1); + access::rw(mem[0]) = val; + return *this; + } + + + +//! In-place addition of a scalar to all elements of the matrix +template +arma_inline +const Mat& +Mat::operator+=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_plus( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place subtraction of a scalar from all elements of the matrix +template +arma_inline +const Mat& +Mat::operator-=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_minus( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place multiplication of all elements of the matrix with a scalar +template +arma_inline +const Mat& +Mat::operator*=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_mul( memptr(), val, n_elem ); + + return *this; + } + + + +//! In-place division of all elements of the matrix with a scalar +template +arma_inline +const Mat& +Mat::operator/=(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_div( memptr(), val, n_elem ); + + return *this; + } + + + +//! construct a matrix from a given matrix +template +inline +Mat::Mat(const Mat& in_mat) + : n_rows(in_mat.n_rows) + , n_cols(in_mat.n_cols) + , n_elem(in_mat.n_elem) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint(arma_boost::format("this = %x in_mat = %x") % this % &in_mat); + + init_cold(); + + arrayops::copy( memptr(), in_mat.mem, in_mat.n_elem ); + } + + + +//! construct a matrix from a given matrix +template +inline +const Mat& +Mat::operator=(const Mat& in_mat) + { + arma_extra_debug_sigprint(arma_boost::format("this = %x in_mat = %x") % this % &in_mat); + + if(this != &in_mat) + { + init_warm(in_mat.n_rows, in_mat.n_cols); + + arrayops::copy( memptr(), in_mat.mem, in_mat.n_elem ); + } + + return *this; + } + + + +#if defined(ARMA_USE_CXX11) + +template +inline +void +Mat::init(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + const uword N = list.size(); + + set_size(1, N); + + arrayops::copy( memptr(), list.begin(), N ); + } + +#endif + + + +//! for constructing a complex matrix out of two non-complex matrices +template +template +inline +void +Mat::init + ( + const Base::pod_type, T1>& A, + const Base::pod_type, T2>& B + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type T; + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + arma_type_check(( is_complex::value == false )); //!< compile-time abort if eT isn't std::complex + arma_type_check(( is_complex< T>::value == true )); //!< compile-time abort if T is std::complex + + arma_type_check(( is_same_type< std::complex, eT >::value == false )); //!< compile-time abort if types are not compatible + + const Proxy X(A.get_ref()); + const Proxy Y(B.get_ref()); + + arma_assert_same_size(X, Y, "Mat()"); + + init_warm(X.get_n_rows(), X.get_n_cols()); + + const uword N = n_elem; + eT* out_mem = memptr(); + ea_type1 PX = X.get_ea(); + ea_type2 PY = Y.get_ea(); + + for(uword i=0; i(PX[i], PY[i]); + } + } + + + +//! try to steal the memory from a given matrix; +//! if memory can't be stolen, copy the given matrix +template +inline +void +Mat::steal_mem(Mat& x) + { + arma_extra_debug_sigprint(); + + if(this != &x) + { + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + const uword x_n_elem = x.n_elem; + const uword x_vec_state = x.vec_state; + const uword x_mem_state = x.mem_state; + + const uword t_vec_state = vec_state; + + bool layout_ok = false; + + if(t_vec_state == x_vec_state) + { + layout_ok = true; + } + else + { + if( (t_vec_state == 1) && ( x_n_cols == 1) ) + { + layout_ok = true; + } + + if( (t_vec_state == 2) && ( x_n_rows == 1) ) + { + layout_ok = true; + } + } + + + if( (x_mem_state == 0) && (x_n_elem > arma_config::mat_prealloc) && (layout_ok == true) ) + { + reset(); + // note: calling reset() also prevents fixed size matrices from changing size or using non-local memory + + access::rw(n_rows) = x_n_rows; + access::rw(n_cols) = x_n_cols; + access::rw(n_elem) = x_n_elem; + access::rw(mem) = x.mem; + + access::rw(x.n_rows) = 0; + access::rw(x.n_cols) = 0; + access::rw(x.n_elem) = 0; + access::rw(x.mem) = 0; + } + else + { + (*this).operator=(x); + } + } + } + + + +//! construct a matrix from a given auxiliary array of eTs. +//! if copy_aux_mem is true, new memory is allocated and the array is copied. +//! if copy_aux_mem is false, the auxiliary array is used directly (without allocating memory and copying). +//! the default is to copy the array. + +template +inline +Mat::Mat(eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols, const bool copy_aux_mem, const bool strict) + : n_rows ( aux_n_rows ) + , n_cols ( aux_n_cols ) + , n_elem ( aux_n_rows*aux_n_cols ) + , vec_state( 0 ) + , mem_state( copy_aux_mem ? 0 : ( strict ? 2 : 1 ) ) + , mem ( copy_aux_mem ? 0 : aux_mem ) + { + arma_extra_debug_sigprint_this(this); + + if(copy_aux_mem == true) + { + init_cold(); + + arrayops::copy( memptr(), aux_mem, n_elem ); + } + } + + + +//! construct a matrix from a given auxiliary read-only array of eTs. +//! the array is copied. +template +inline +Mat::Mat(const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols) + : n_rows(aux_n_rows) + , n_cols(aux_n_cols) + , n_elem(aux_n_rows*aux_n_cols) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + arrayops::copy( memptr(), aux_mem, n_elem ); + } + + + +//! DANGEROUS! Construct a temporary matrix, using auxiliary memory. +//! This constructor is NOT intended for usage by user code. +//! Its sole purpose is to be used by the Cube class. + +template +inline +Mat::Mat(const char junk, const eT* aux_mem, const uword aux_n_rows, const uword aux_n_cols) + : n_rows (aux_n_rows ) + , n_cols (aux_n_cols ) + , n_elem (aux_n_rows*aux_n_cols) + , vec_state(0 ) + , mem_state(3 ) + , mem (aux_mem ) + { + arma_extra_debug_sigprint_this(this); + arma_ignore(junk); + } + + + +//! in-place matrix addition +template +inline +const Mat& +Mat::operator+=(const Mat& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "addition"); + + arrayops::inplace_plus( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place matrix subtraction +template +inline +const Mat& +Mat::operator-=(const Mat& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "subtraction"); + + arrayops::inplace_minus( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place matrix multiplication +template +inline +const Mat& +Mat::operator*=(const Mat& m) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace(*this, m); + + return *this; + } + + + +//! in-place element-wise matrix multiplication +template +inline +const Mat& +Mat::operator%=(const Mat& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "element-wise multiplication"); + + arrayops::inplace_mul( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +//! in-place element-wise matrix division +template +inline +const Mat& +Mat::operator/=(const Mat& m) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(*this, m, "element-wise division"); + + arrayops::inplace_div( memptr(), m.memptr(), n_elem ); + + return *this; + } + + + +template +template +inline +Mat::Mat(const BaseCube& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + (*this).operator=(X); + } + + + +template +template +inline +const Mat& +Mat::operator=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat& out = *this; + + const unwrap_cube tmp(X.get_ref()); + const Cube& in = tmp.M; + + arma_debug_assert_cube_as_mat(out, in, "copy into matrix", false); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + out.set_size(in_n_rows, in_n_cols); + + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::copy( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if(in_n_cols == 1) + { + out.set_size(in_n_rows, in_n_slices); + + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::copy( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if(in_n_rows == 1) + { + out.set_size(in_n_cols, in_n_slices); + + for(uword slice=0; slice < in_n_slices; ++slice) + { + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = in.at(0, i, slice); + const eT tmp_j = in.at(0, j, slice); + + out_colptr[i] = tmp_i; + out_colptr[j] = tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] = in.at(0, i, slice); + } + } + } + } + else + { + out.set_size(in_n_slices); + + eT* out_mem = out.memptr(); + + for(uword i=0; i +template +inline +const Mat& +Mat::operator+=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat& out = *this; + + const unwrap_cube tmp(X.get_ref()); + const Cube& in = tmp.M; + + arma_debug_assert_cube_as_mat(out, in, "addition", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_plus( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_plus( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + for(uword slice=0; slice < in_n_slices; ++slice) + { + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = in.at(0, i, slice); + const eT tmp_j = in.at(0, j, slice); + + out_colptr[i] += tmp_i; + out_colptr[j] += tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] += in.at(0, i, slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + for(uword i=0; i +template +inline +const Mat& +Mat::operator-=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat& out = *this; + + const unwrap_cube tmp(X.get_ref()); + const Cube& in = tmp.M; + + arma_debug_assert_cube_as_mat(out, in, "subtraction", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_minus( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_minus( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + for(uword slice=0; slice < in_n_slices; ++slice) + { + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = in.at(0, i, slice); + const eT tmp_j = in.at(0, j, slice); + + out_colptr[i] -= tmp_i; + out_colptr[j] -= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] -= in.at(0, i, slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + for(uword i=0; i +template +inline +const Mat& +Mat::operator*=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + const Mat B(X); + + (*this).operator*=(B); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator%=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat& out = *this; + + const unwrap_cube tmp(X.get_ref()); + const Cube& in = tmp.M; + + arma_debug_assert_cube_as_mat(out, in, "element-wise multiplication", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_mul( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_mul( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + for(uword slice=0; slice < in_n_slices; ++slice) + { + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = in.at(0, i, slice); + const eT tmp_j = in.at(0, j, slice); + + out_colptr[i] *= tmp_i; + out_colptr[j] *= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] *= in.at(0, i, slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + for(uword i=0; i +template +inline +const Mat& +Mat::operator/=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat& out = *this; + + const unwrap_cube tmp(X.get_ref()); + const Cube& in = tmp.M; + + arma_debug_assert_cube_as_mat(out, in, "element-wise division", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_div( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_div( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + for(uword slice=0; slice < in_n_slices; ++slice) + { + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = in.at(0, i, slice); + const eT tmp_j = in.at(0, j, slice); + + out_colptr[i] /= tmp_i; + out_colptr[j] /= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] /= in.at(0, i, slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + for(uword i=0; i +template +inline +Mat::Mat + ( + const Base::pod_type,T1>& A, + const Base::pod_type,T2>& B + ) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init(A,B); + } + + + +//! construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation) +template +inline +Mat::Mat(const subview& X) + : n_rows(X.n_rows) + , n_cols(X.n_cols) + , n_elem(X.n_elem) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + subview::extract(*this, X); + } + + + +//! construct a matrix from subview (e.g. construct a matrix from a delayed submatrix operation) +template +inline +const Mat& +Mat::operator=(const subview& X) + { + arma_extra_debug_sigprint(); + + const bool alias = (this == &(X.m)); + + if(alias == false) + { + init_warm(X.n_rows, X.n_cols); + + subview::extract(*this, X); + } + else + { + Mat tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + +//! in-place matrix addition (using a submatrix on the right-hand-side) +template +inline +const Mat& +Mat::operator+=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::plus_inplace(*this, X); + + return *this; + } + + +//! in-place matrix subtraction (using a submatrix on the right-hand-side) +template +inline +const Mat& +Mat::operator-=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::minus_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix mutiplication (using a submatrix on the right-hand-side) +template +inline +const Mat& +Mat::operator*=(const subview& X) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise matrix mutiplication (using a submatrix on the right-hand-side) +template +inline +const Mat& +Mat::operator%=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::schur_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise matrix division (using a submatrix on the right-hand-side) +template +inline +const Mat& +Mat::operator/=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::div_inplace(*this, X); + + return *this; + } + + + +//! construct a matrix from a subview_cube instance +template +inline +Mat::Mat(const subview_cube& x) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + this->operator=(x); + } + + + +//! construct a matrix from a subview_cube instance +template +inline +const Mat& +Mat::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::extract(*this, X); + + return *this; + } + + + +//! in-place matrix addition (using a single-slice subcube on the right-hand-side) +template +inline +const Mat& +Mat::operator+=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::plus_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix subtraction (using a single-slice subcube on the right-hand-side) +template +inline +const Mat& +Mat::operator-=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::minus_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix mutiplication (using a single-slice subcube on the right-hand-side) +template +inline +const Mat& +Mat::operator*=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + const Mat tmp(X); + glue_times::apply_inplace(*this, tmp); + + return *this; + } + + + +//! in-place element-wise matrix mutiplication (using a single-slice subcube on the right-hand-side) +template +inline +const Mat& +Mat::operator%=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::schur_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise matrix division (using a single-slice subcube on the right-hand-side) +template +inline +const Mat& +Mat::operator/=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + subview_cube::div_inplace(*this, X); + + return *this; + } + + + +//! construct a matrix from diagview (e.g. construct a matrix from a delayed diag operation) +template +inline +Mat::Mat(const diagview& X) + : n_rows(X.n_rows) + , n_cols(X.n_cols) + , n_elem(X.n_elem) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + diagview::extract(*this, X); + } + + + +//! construct a matrix from diagview (e.g. construct a matrix from a delayed diag operation) +template +inline +const Mat& +Mat::operator=(const diagview& X) + { + arma_extra_debug_sigprint(); + + const bool alias = (this == &(X.m)); + + if(alias == false) + { + init_warm(X.n_rows, X.n_cols); + + diagview::extract(*this, X); + } + else + { + Mat tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +//! in-place matrix addition (using a diagview on the right-hand-side) +template +inline +const Mat& +Mat::operator+=(const diagview& X) + { + arma_extra_debug_sigprint(); + + diagview::plus_inplace(*this, X); + + return *this; + } + + +//! in-place matrix subtraction (using a diagview on the right-hand-side) +template +inline +const Mat& +Mat::operator-=(const diagview& X) + { + arma_extra_debug_sigprint(); + + diagview::minus_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix mutiplication (using a diagview on the right-hand-side) +template +inline +const Mat& +Mat::operator*=(const diagview& X) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise matrix mutiplication (using a diagview on the right-hand-side) +template +inline +const Mat& +Mat::operator%=(const diagview& X) + { + arma_extra_debug_sigprint(); + + diagview::schur_inplace(*this, X); + + return *this; + } + + + +//! in-place element-wise matrix division (using a diagview on the right-hand-side) +template +inline +const Mat& +Mat::operator/=(const diagview& X) + { + arma_extra_debug_sigprint(); + + diagview::div_inplace(*this, X); + + return *this; + } + + + +template +template +inline +Mat::Mat(const subview_elem1& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + this->operator=(X); + } + + + +template +template +inline +const Mat& +Mat::operator=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + subview_elem1::extract(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator+=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + subview_elem1::plus_inplace(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator-=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + subview_elem1::minus_inplace(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator*=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator%=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + subview_elem1::schur_inplace(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator/=(const subview_elem1& X) + { + arma_extra_debug_sigprint(); + + subview_elem1::div_inplace(*this, X); + + return *this; + } + + + +template +inline +mat_injector< Mat > +Mat::operator<<(const eT val) + { + return mat_injector< Mat >(*this, val); + } + + + +template +inline +mat_injector< Mat > +Mat::operator<<(const injector_end_of_row& x) + { + return mat_injector< Mat >(*this, x); + } + + + +//! creation of subview (row vector) +template +arma_inline +subview_row +Mat::row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= n_rows, "Mat::row(): out of bounds" ); + + return subview_row(*this, row_num); + } + + + +//! creation of subview (row vector) +template +arma_inline +const subview_row +Mat::row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= n_rows, "Mat::row(): out of bounds" ); + + return subview_row(*this, row_num); + } + + + +template +inline +subview_row +Mat::operator()(const uword row_num, const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + (row_num >= n_rows) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "Mat::operator(): indices out of bounds or incorrectly used" + ); + + return subview_row(*this, row_num, in_col1, submat_n_cols); + } + + + +template +inline +const subview_row +Mat::operator()(const uword row_num, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + (row_num >= n_rows) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "Mat::operator(): indices out of bounds or incorrectly used" + ); + + return subview_row(*this, row_num, in_col1, submat_n_cols); + } + + + +//! creation of subview (column vector) +template +arma_inline +subview_col +Mat::col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "Mat::col(): out of bounds"); + + return subview_col(*this, col_num); + } + + + +//! creation of subview (column vector) +template +arma_inline +const subview_col +Mat::col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "Mat::col(): out of bounds"); + + return subview_col(*this, col_num); + } + + + +template +inline +subview_col +Mat::operator()(const span& row_span, const uword col_num) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + arma_debug_check + ( + (col_num >= n_cols) + || + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + , + "Mat::operator(): indices out of bounds or incorrectly used" + ); + + return subview_col(*this, col_num, in_row1, submat_n_rows); + } + + + +template +inline +const subview_col +Mat::operator()(const span& row_span, const uword col_num) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + arma_debug_check + ( + (col_num >= n_cols) + || + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + , + "Mat::operator(): indices out of bounds or incorrectly used" + ); + + return subview_col(*this, col_num, in_row1, submat_n_rows); + } + + + +//! create a Col object which uses memory from an existing matrix object. +//! this approach is currently not alias safe +//! and does not take into account that the parent matrix object could be deleted. +//! if deleted memory is accessed by the created Col object, +//! it will cause memory corruption and/or a crash +template +inline +Col +Mat::unsafe_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "Mat::unsafe_col(): out of bounds"); + + return Col(colptr(col_num), n_rows, false, true); + } + + + +//! create a Col object which uses memory from an existing matrix object. +//! this approach is currently not alias safe +//! and does not take into account that the parent matrix object could be deleted. +//! if deleted memory is accessed by the created Col object, +//! it will cause memory corruption and/or a crash +template +inline +const Col +Mat::unsafe_col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "Mat::unsafe_col(): out of bounds"); + + typedef const Col out_type; + + return out_type(const_cast(colptr(col_num)), n_rows, false, true); + } + + + +//! creation of subview (submatrix comprised of specified row vectors) +template +arma_inline +subview +Mat::rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= n_rows), + "Mat::rows(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview(*this, in_row1, 0, subview_n_rows, n_cols ); + } + + + +//! creation of subview (submatrix comprised of specified row vectors) +template +arma_inline +const subview +Mat::rows(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= n_rows), + "Mat::rows(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + return subview(*this, in_row1, 0, subview_n_rows, n_cols ); + } + + + +//! creation of subview (submatrix comprised of specified column vectors) +template +arma_inline +subview +Mat::cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= n_cols), + "Mat::cols(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview(*this, 0, in_col1, n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix comprised of specified column vectors) +template +arma_inline +const subview +Mat::cols(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= n_cols), + "Mat::cols(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview(*this, 0, in_col1, n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix) +template +arma_inline +subview +Mat::submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "Mat::submat(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview(*this, in_row1, in_col1, subview_n_rows, subview_n_cols); + } + + + +//! creation of subview (generic submatrix) +template +arma_inline +const subview +Mat::submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "Mat::submat(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview(*this, in_row1, in_col1, subview_n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix) +template +inline +subview +Mat::submat(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "Mat::submat(): indices out of bounds or incorrectly used" + ); + + return subview(*this, in_row1, in_col1, submat_n_rows, submat_n_cols); + } + + + +//! creation of subview (generic submatrix) +template +inline +const subview +Mat::submat(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "Mat::submat(): indices out of bounds or incorrectly used" + ); + + return subview(*this, in_row1, in_col1, submat_n_rows, submat_n_cols); + } + + + +template +inline +subview +Mat::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return (*this).submat(row_span, col_span); + } + + + +template +inline +const subview +Mat::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return (*this).submat(row_span, col_span); + } + + + +template +template +arma_inline +subview_elem1 +Mat::elem(const Base& a) + { + arma_extra_debug_sigprint(); + + return subview_elem1(*this, a); + } + + + +template +template +arma_inline +const subview_elem1 +Mat::elem(const Base& a) const + { + arma_extra_debug_sigprint(); + + return subview_elem1(*this, a); + } + + + +// template +// template +// arma_inline +// subview_elem2 +// Mat::elem(const Base& a, const Base& b) +// { +// arma_extra_debug_sigprint(); +// +// return subview_elem2(*this, a, b); +// } +// +// +// +// template +// template +// arma_inline +// const subview_elem2 +// Mat::elem(const Base& a, const Base& b) const +// { +// arma_extra_debug_sigprint(); +// +// return subview_elem2(*this, a, b); +// } + + + +//! creation of diagview (diagonal) +template +arma_inline +diagview +Mat::diag(const sword in_id) + { + arma_extra_debug_sigprint(); + + const uword row_offset = (in_id < 0) ? uword(-in_id) : 0; + const uword col_offset = (in_id > 0) ? uword( in_id) : 0; + + arma_debug_check + ( + ((row_offset > 0) && (row_offset >= n_rows)) || ((col_offset > 0) && (col_offset >= n_cols)), + "Mat::diag(): requested diagonal out of bounds" + ); + + const uword len = (std::min)(n_rows - row_offset, n_cols - col_offset); + + return diagview(*this, row_offset, col_offset, len); + } + + + +//! creation of diagview (diagonal) +template +arma_inline +const diagview +Mat::diag(const sword in_id) const + { + arma_extra_debug_sigprint(); + + const uword row_offset = (in_id < 0) ? -in_id : 0; + const uword col_offset = (in_id > 0) ? in_id : 0; + + arma_debug_check + ( + ((row_offset > 0) && (row_offset >= n_rows)) || ((col_offset > 0) && (col_offset >= n_cols)), + "Mat::diag(): requested diagonal out of bounds" + ); + + const uword len = (std::min)(n_rows - row_offset, n_cols - col_offset); + + return diagview(*this, row_offset, col_offset, len); + } + + + +template +inline +void +Mat::swap_rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 >= n_rows) || (in_row2 >= n_rows), + "Mat::swap_rows(): out of bounds" + ); + + for(uword col=0; col +inline +void +Mat::swap_cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 >= n_cols) || (in_col2 >= n_cols), + "Mat::swap_cols(): out of bounds" + ); + + if(n_elem > 0) + { + eT* ptr1 = colptr(in_col1); + eT* ptr2 = colptr(in_col2); + + for(uword row=0; row +inline +void +Mat::shed_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= n_rows, "Mat::shed_row(): out of bounds"); + + shed_rows(row_num, row_num); + } + + + +//! remove specified column +template +inline +void +Mat::shed_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "Mat::shed_col(): out of bounds"); + + shed_cols(col_num, col_num); + } + + + +//! remove specified rows +template +inline +void +Mat::shed_rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= n_rows), + "Mat::shed_rows(): indices out of bounds or incorrectly used" + ); + + const uword n_keep_front = in_row1; + const uword n_keep_back = n_rows - (in_row2 + 1); + + Mat X(n_keep_front + n_keep_back, n_cols); + + if(n_keep_front > 0) + { + X.rows( 0, (n_keep_front-1) ) = rows( 0, (in_row1-1) ); + } + + if(n_keep_back > 0) + { + X.rows( n_keep_front, (n_keep_front+n_keep_back-1) ) = rows( (in_row2+1), (n_rows-1) ); + } + + steal_mem(X); + } + + + +//! remove specified columns +template +inline +void +Mat::shed_cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= n_cols), + "Mat::shed_cols(): indices out of bounds or incorrectly used" + ); + + const uword n_keep_front = in_col1; + const uword n_keep_back = n_cols - (in_col2 + 1); + + Mat X(n_rows, n_keep_front + n_keep_back); + + if(n_keep_front > 0) + { + X.cols( 0, (n_keep_front-1) ) = cols( 0, (in_col1-1) ); + } + + if(n_keep_back > 0) + { + X.cols( n_keep_front, (n_keep_front+n_keep_back-1) ) = cols( (in_col2+1), (n_cols-1) ); + } + + steal_mem(X); + } + + + +//! insert N rows at the specified row position, +//! optionally setting the elements of the inserted rows to zero +template +inline +void +Mat::insert_rows(const uword row_num, const uword N, const bool set_to_zero) + { + arma_extra_debug_sigprint(); + + const uword t_n_rows = n_rows; + const uword t_n_cols = n_cols; + + const uword A_n_rows = row_num; + const uword B_n_rows = t_n_rows - row_num; + + // insertion at row_num == n_rows is in effect an append operation + arma_debug_check( (row_num > t_n_rows), "Mat::insert_rows(): out of bounds"); + + if(N > 0) + { + Mat out(t_n_rows + N, t_n_cols); + + if(A_n_rows > 0) + { + out.rows(0, A_n_rows-1) = rows(0, A_n_rows-1); + } + + if(B_n_rows > 0) + { + out.rows(row_num + N, t_n_rows + N - 1) = rows(row_num, t_n_rows-1); + } + + if(set_to_zero == true) + { + out.rows(row_num, row_num + N - 1).zeros(); + } + + steal_mem(out); + } + } + + + +//! insert N columns at the specified column position, +//! optionally setting the elements of the inserted columns to zero +template +inline +void +Mat::insert_cols(const uword col_num, const uword N, const bool set_to_zero) + { + arma_extra_debug_sigprint(); + + const uword t_n_rows = n_rows; + const uword t_n_cols = n_cols; + + const uword A_n_cols = col_num; + const uword B_n_cols = t_n_cols - col_num; + + // insertion at col_num == n_cols is in effect an append operation + arma_debug_check( (col_num > t_n_cols), "Mat::insert_cols(): out of bounds"); + + if(N > 0) + { + Mat out(t_n_rows, t_n_cols + N); + + if(A_n_cols > 0) + { + out.cols(0, A_n_cols-1) = cols(0, A_n_cols-1); + } + + if(B_n_cols > 0) + { + out.cols(col_num + N, t_n_cols + N - 1) = cols(col_num, t_n_cols-1); + } + + if(set_to_zero == true) + { + out.cols(col_num, col_num + N - 1).zeros(); + } + + steal_mem(out); + } + } + + + +//! insert the given object at the specified row position; +//! the given object must have the same number of columns as the matrix +template +template +inline +void +Mat::insert_rows(const uword row_num, const Base& X) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(X.get_ref()); + const Mat& C = tmp.M; + + const uword C_n_rows = C.n_rows; + const uword C_n_cols = C.n_cols; + + const uword t_n_rows = n_rows; + const uword t_n_cols = n_cols; + + const uword A_n_rows = row_num; + const uword B_n_rows = t_n_rows - row_num; + + bool err_state = false; + char* err_msg = 0; + + // insertion at row_num == n_rows is in effect an append operation + + arma_debug_set_error + ( + err_state, + err_msg, + (row_num > t_n_rows), + "Mat::insert_rows(): out of bounds" + ); + + arma_debug_set_error + ( + err_state, + err_msg, + ( (C_n_cols != t_n_cols) && ( (t_n_rows > 0) || (t_n_cols > 0) ) && ( (C_n_rows > 0) || (C_n_cols > 0) ) ), + "Mat::insert_rows(): given object has an incompatible number of columns" + ); + + arma_debug_check(err_state, err_msg); + + if(C_n_rows > 0) + { + Mat out( t_n_rows + C_n_rows, (std::max)(t_n_cols, C_n_cols) ); + + if(t_n_cols > 0) + { + if(A_n_rows > 0) + { + out.rows(0, A_n_rows-1) = rows(0, A_n_rows-1); + } + + if( (t_n_cols > 0) && (B_n_rows > 0) ) + { + out.rows(row_num + C_n_rows, t_n_rows + C_n_rows - 1) = rows(row_num, t_n_rows - 1); + } + } + + if(C_n_cols > 0) + { + out.rows(row_num, row_num + C_n_rows - 1) = C; + } + + steal_mem(out); + } + } + + + +//! insert the given object at the specified column position; +//! the given object must have the same number of rows as the matrix +template +template +inline +void +Mat::insert_cols(const uword col_num, const Base& X) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(X.get_ref()); + const Mat& C = tmp.M; + + const uword C_n_rows = C.n_rows; + const uword C_n_cols = C.n_cols; + + const uword t_n_rows = n_rows; + const uword t_n_cols = n_cols; + + const uword A_n_cols = col_num; + const uword B_n_cols = t_n_cols - col_num; + + bool err_state = false; + char* err_msg = 0; + + // insertion at col_num == n_cols is in effect an append operation + + arma_debug_set_error + ( + err_state, + err_msg, + (col_num > t_n_cols), + "Mat::insert_cols(): out of bounds" + ); + + arma_debug_set_error + ( + err_state, + err_msg, + ( (C_n_rows != t_n_rows) && ( (t_n_rows > 0) || (t_n_cols > 0) ) && ( (C_n_rows > 0) || (C_n_cols > 0) ) ), + "Mat::insert_cols(): given object has an incompatible number of rows" + ); + + arma_debug_check(err_state, err_msg); + + if(C_n_cols > 0) + { + Mat out( (std::max)(t_n_rows, C_n_rows), t_n_cols + C_n_cols ); + + if(t_n_rows > 0) + { + if(A_n_cols > 0) + { + out.cols(0, A_n_cols-1) = cols(0, A_n_cols-1); + } + + if(B_n_cols > 0) + { + out.cols(col_num + C_n_cols, t_n_cols + C_n_cols - 1) = cols(col_num, t_n_cols - 1); + } + } + + if(C_n_rows > 0) + { + out.cols(col_num, col_num + C_n_cols - 1) = C; + } + + steal_mem(out); + } + } + + + +template +template +inline +Mat::Mat(const Gen& X) + : n_rows(X.n_rows) + , n_cols(X.n_cols) + , n_elem(n_rows*n_cols) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + init_cold(); + + X.apply(*this); + } + + + +template +template +inline +const Mat& +Mat::operator=(const Gen& X) + { + arma_extra_debug_sigprint(); + + init_warm(X.n_rows, X.n_cols); + + X.apply(*this); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator+=(const Gen& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_plus(*this); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator-=(const Gen& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_minus(*this); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator*=(const Gen& X) + { + arma_extra_debug_sigprint(); + + const Mat tmp(X); + + return (*this).operator*=(tmp); + } + + + +template +template +inline +const Mat& +Mat::operator%=(const Gen& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_schur(*this); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator/=(const Gen& X) + { + arma_extra_debug_sigprint(); + + X.apply_inplace_div(*this); + + return *this; + } + + + +//! create a matrix from Op, i.e. run the previously delayed unary operations +template +template +inline +Mat::Mat(const Op& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + op_type::apply(*this, X); + } + + + +//! create a matrix from Op, i.e. run the previously delayed unary operations +template +template +inline +const Mat& +Mat::operator=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + op_type::apply(*this, X); + + return *this; + } + + + +//! in-place matrix addition, with the right-hand-side operand having delayed operations +template +template +inline +const Mat& +Mat::operator+=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator+=(m); + } + + + +//! in-place matrix subtraction, with the right-hand-side operand having delayed operations +template +template +inline +const Mat& +Mat::operator-=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator-=(m); + } + + + +//! in-place matrix multiplication, with the right-hand-side operand having delayed operations +template +template +inline +const Mat& +Mat::operator*=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix element-wise multiplication, with the right-hand-side operand having delayed operations +template +template +inline +const Mat& +Mat::operator%=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator%=(m); + } + + + +//! in-place matrix element-wise division, with the right-hand-side operand having delayed operations +template +template +inline +const Mat& +Mat::operator/=(const Op& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator/=(m); + } + + + +//! create a matrix from eOp, i.e. run the previously delayed unary operations +template +template +inline +Mat::Mat(const eOp& X) + : n_rows(X.get_n_rows()) + , n_cols(X.get_n_cols()) + , n_elem(X.get_n_elem()) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + init_cold(); + + eop_type::apply(*this, X); + } + + + +//! create a matrix from eOp, i.e. run the previously delayed unary operations +template +template +inline +const Mat& +Mat::operator=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + const bool bad_alias = (X.P.has_subview && X.P.is_alias(*this)); + + if(bad_alias == false) + { + init_warm(X.get_n_rows(), X.get_n_cols()); + + eop_type::apply(*this, X); + } + else + { + Mat tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator+=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_plus(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator-=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_minus(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator*=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator%=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_schur(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator/=(const eOp& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + + eop_type::apply_inplace_div(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +Mat::Mat(const mtOp& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + op_type::apply(*this, X); + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + op_type::apply(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator+=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator+=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator-=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator-=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator*=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator*=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator%=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator%=(m); + } + + + +//! EXPERIMENTAL +template +template +inline +const Mat& +Mat::operator/=(const mtOp& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator/=(m); + } + + + +//! create a matrix from Glue, i.e. run the previously delayed binary operations +template +template +inline +Mat::Mat(const Glue& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + glue_type::apply(*this, X); + } + + + +//! create a matrix from Glue, i.e. run the previously delayed binary operations +template +template +inline +const Mat& +Mat::operator=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + glue_type::apply(*this, X); + + return *this; + } + + + +//! in-place matrix addition, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator+=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator+=(m); + } + + + +//! in-place matrix subtraction, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator-=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator-=(m); + } + + + +//! in-place matrix multiplications, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator*=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + glue_times::apply_inplace(*this, X); + + return *this; + } + + + +//! in-place matrix element-wise multiplication, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator%=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator%=(m); + } + + + +//! in-place matrix element-wise division, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator/=(const Glue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const Mat m(X); + + return (*this).operator/=(m); + } + + + +template +template +inline +const Mat& +Mat::operator+=(const Glue& X) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace_plus(*this, X, sword(+1)); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator-=(const Glue& X) + { + arma_extra_debug_sigprint(); + + glue_times::apply_inplace_plus(*this, X, sword(-1)); + + return *this; + } + + + +//! create a matrix from eGlue, i.e. run the previously delayed binary operations +template +template +inline +Mat::Mat(const eGlue& X) + : n_rows(X.get_n_rows()) + , n_cols(X.get_n_cols()) + , n_elem(X.get_n_elem()) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + init_cold(); + + eglue_type::apply(*this, X); + } + + + +//! create a matrix from eGlue, i.e. run the previously delayed binary operations +template +template +inline +const Mat& +Mat::operator=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + const bool bad_alias = ( (X.P1.has_subview && X.P1.is_alias(*this)) || ( X.P2.has_subview && X.P2.is_alias(*this)) ); + + if(bad_alias == false) + { + init_warm(X.get_n_rows(), X.get_n_cols()); + + eglue_type::apply(*this, X); + } + else + { + Mat tmp(X); + + steal_mem(tmp); + } + + return *this; + } + + + +//! in-place matrix addition, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator+=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_plus(*this, X); + + return *this; + } + + + +//! in-place matrix subtraction, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator-=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_minus(*this, X); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator*=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + glue_times::apply_inplace(*this, X); + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator%=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_schur(*this, X); + return *this; + } + + + +template +template +inline +const Mat& +Mat::operator/=(const eGlue& X) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type< eT, typename T1::elem_type >::value == false )); + arma_type_check(( is_same_type< eT, typename T2::elem_type >::value == false )); + + eglue_type::apply_inplace_div(*this, X); + return *this; + } + + + +//! EXPERIMENTAL: create a matrix from mtGlue, i.e. run the previously delayed binary operations +template +template +inline +Mat::Mat(const mtGlue& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , vec_state(0) + , mem_state(0) + , mem() + { + arma_extra_debug_sigprint_this(this); + + glue_type::apply(*this, X); + } + + + +//! EXPERIMENTAL: create a matrix from Glue, i.e. run the previously delayed binary operations +template +template +inline +const Mat& +Mat::operator=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + glue_type::apply(*this, X); + + return *this; + } + + + +//! EXPERIMENTAL: in-place matrix addition, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator+=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator+=(m); + } + + + +//! EXPERIMENTAL: in-place matrix subtraction, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator-=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator-=(m); + } + + + +//! EXPERIMENTAL: in-place matrix multiplications, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator*=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + glue_times::apply_inplace(*this, m); + + return *this; + } + + + +//! EXPERIMENTAL: in-place matrix element-wise multiplication, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator%=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator%=(m); + } + + + +//! EXPERIMENTAL: in-place matrix element-wise division, with the right-hand-side operands having delayed operations +template +template +inline +const Mat& +Mat::operator/=(const mtGlue& X) + { + arma_extra_debug_sigprint(); + + const Mat m(X); + + return (*this).operator/=(m); + } + + + +//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT& +Mat::operator() (const uword i) + { + arma_debug_check( (i >= n_elem), "Mat::operator(): out of bounds"); + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT +Mat::operator() (const uword i) const + { + arma_debug_check( (i >= n_elem), "Mat::operator(): out of bounds"); + return mem[i]; + } + + +//! linear element accessor (treats the matrix as a vector); no bounds check. +template +arma_inline +arma_warn_unused +eT& +Mat::operator[] (const uword i) + { + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the matrix as a vector); no bounds check +template +arma_inline +arma_warn_unused +eT +Mat::operator[] (const uword i) const + { + return mem[i]; + } + + + +//! linear element accessor (treats the matrix as a vector); no bounds check. +template +arma_inline +arma_warn_unused +eT& +Mat::at(const uword i) + { + return access::rw(mem[i]); + } + + + +//! linear element accessor (treats the matrix as a vector); no bounds check +template +arma_inline +arma_warn_unused +eT +Mat::at(const uword i) const + { + return mem[i]; + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT& +Mat::operator() (const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "Mat::operator(): out of bounds"); + return access::rw(mem[in_row + in_col*n_rows]); + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +arma_warn_unused +eT +Mat::operator() (const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "Mat::operator(): out of bounds"); + return mem[in_row + in_col*n_rows]; + } + + + +//! element accessor; no bounds check +template +arma_inline +arma_warn_unused +eT& +Mat::at(const uword in_row, const uword in_col) + { + return access::rw( mem[in_row + in_col*n_rows] ); + } + + + +//! element accessor; no bounds check +template +arma_inline +arma_warn_unused +eT +Mat::at(const uword in_row, const uword in_col) const + { + return mem[in_row + in_col*n_rows]; + } + + + +//! prefix ++ +template +arma_inline +const Mat& +Mat::operator++() + { + Mat_aux::prefix_pp(*this); + return *this; + } + + + +//! postfix ++ (must not return the object by reference) +template +arma_inline +void +Mat::operator++(int) + { + Mat_aux::postfix_pp(*this); + } + + + +//! prefix -- +template +arma_inline +const Mat& +Mat::operator--() + { + Mat_aux::prefix_mm(*this); + return *this; + } + + + +//! postfix -- (must not return the object by reference) +template +arma_inline +void +Mat::operator--(int) + { + Mat_aux::postfix_mm(*this); + } + + + +//! returns true if the matrix has no elements +template +arma_inline +arma_warn_unused +bool +Mat::is_empty() const + { + return (n_elem == 0); + } + + + +//! returns true if the object can be interpreted as a column or row vector +template +arma_inline +arma_warn_unused +bool +Mat::is_vec() const + { + return ( (n_rows == 1) || (n_cols == 1) ); + } + + + +//! returns true if the object can be interpreted as a row vector +template +arma_inline +arma_warn_unused +bool +Mat::is_rowvec() const + { + return (n_rows == 1); + } + + + +//! returns true if the object can be interpreted as a column vector +template +arma_inline +arma_warn_unused +bool +Mat::is_colvec() const + { + return (n_cols == 1); + } + + + +//! returns true if the object has the same number of non-zero rows and columnns +template +arma_inline +arma_warn_unused +bool +Mat::is_square() const + { + return (n_rows == n_cols); + } + + + +//! returns true if all of the elements are finite +template +inline +arma_warn_unused +bool +Mat::is_finite() const + { + return arrayops::is_finite( memptr(), n_elem ); + } + + + +//! returns true if the given index is currently in range +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const uword i) const + { + return (i < n_elem); + } + + + +//! returns true if the given start and end indices are currently in range +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const span& x) const + { + arma_extra_debug_sigprint(); + + if(x.whole == true) + { + return true; + } + else + { + const uword a = x.a; + const uword b = x.b; + + return ( (a <= b) && (b < n_elem) ); + } + } + + + +//! returns true if the given location is currently in range +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const uword in_row, const uword in_col) const + { + return ( (in_row < n_rows) && (in_col < n_cols) ); + } + + + +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const span& row_span, const uword in_col) const + { + arma_extra_debug_sigprint(); + + if(row_span.whole == true) + { + return (in_col < n_cols); + } + else + { + const uword in_row1 = row_span.a; + const uword in_row2 = row_span.b; + + return ( (in_row1 <= in_row2) && (in_row2 < n_rows) && (in_col < n_cols) ); + } + } + + + +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const uword in_row, const span& col_span) const + { + arma_extra_debug_sigprint(); + + if(col_span.whole == true) + { + return (in_row < n_rows); + } + else + { + const uword in_col1 = col_span.a; + const uword in_col2 = col_span.b; + + return ( (in_row < n_rows) && (in_col1 <= in_col2) && (in_col2 < n_cols) ); + } + } + + + +template +arma_inline +arma_warn_unused +bool +Mat::in_range(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const uword in_row1 = row_span.a; + const uword in_row2 = row_span.b; + + const uword in_col1 = col_span.a; + const uword in_col2 = col_span.b; + + const bool rows_ok = row_span.whole ? true : ( (in_row1 <= in_row2) && (in_row2 < n_rows) ); + const bool cols_ok = col_span.whole ? true : ( (in_col1 <= in_col2) && (in_col2 < n_cols) ); + + return ( (rows_ok == true) && (cols_ok == true) ); + } + + + +//! returns a pointer to array of eTs for a specified column; no bounds check +template +arma_inline +arma_warn_unused +eT* +Mat::colptr(const uword in_col) + { + return & access::rw(mem[in_col*n_rows]); + } + + + +//! returns a pointer to array of eTs for a specified column; no bounds check +template +arma_inline +arma_warn_unused +const eT* +Mat::colptr(const uword in_col) const + { + return & mem[in_col*n_rows]; + } + + + +//! returns a pointer to array of eTs used by the matrix +template +arma_inline +arma_warn_unused +eT* +Mat::memptr() + { + return const_cast(mem); + } + + + +//! returns a pointer to array of eTs used by the matrix +template +arma_inline +arma_warn_unused +const eT* +Mat::memptr() const + { + return mem; + } + + + +//! print contents of the matrix (to the cout stream), +//! optionally preceding with a user specified line of text. +//! the precision and cell width are modified. +//! on return, the stream's state are restored to their original values. +template +inline +void +Mat::impl_print(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = ARMA_DEFAULT_OSTREAM.width(); + + ARMA_DEFAULT_OSTREAM << extra_text << '\n'; + + ARMA_DEFAULT_OSTREAM.width(orig_width); + } + + arma_ostream::print(ARMA_DEFAULT_OSTREAM, *this, true); + } + + + +//! print contents of the matrix to a user specified stream, +//! optionally preceding with a user specified line of text. +//! the precision and cell width are modified. +//! on return, the stream's state are restored to their original values. +template +inline +void +Mat::impl_print(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = user_stream.width(); + + user_stream << extra_text << '\n'; + + user_stream.width(orig_width); + } + + arma_ostream::print(user_stream, *this, true); + } + + + +//! DEPRECATED FUNCTION +template +inline +void +Mat::impl_print_trans(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + Mat tmp; + op_strans::apply_noalias(tmp, *this); + + tmp.impl_print(extra_text); + } + + + +//! DEPRECATED FUNCTION +template +inline +void +Mat::impl_print_trans(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + Mat tmp; + op_strans::apply_noalias(tmp, *this); + + tmp.impl_print(user_stream, extra_text); + } + + + +//! print contents of the matrix (to the cout stream), +//! optionally preceding with a user specified line of text. +//! the stream's state are used as is and are not modified +//! (i.e. the precision and cell width are not modified). +template +inline +void +Mat::impl_raw_print(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = ARMA_DEFAULT_OSTREAM.width(); + + ARMA_DEFAULT_OSTREAM << extra_text << '\n'; + + ARMA_DEFAULT_OSTREAM.width(orig_width); + } + + arma_ostream::print(ARMA_DEFAULT_OSTREAM, *this, false); + } + + + +//! print contents of the matrix to a user specified stream, +//! optionally preceding with a user specified line of text. +//! the stream's state are used as is and are not modified. +//! (i.e. the precision and cell width are not modified). +template +inline +void +Mat::impl_raw_print(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = user_stream.width(); + + user_stream << extra_text << '\n'; + + user_stream.width(orig_width); + } + + arma_ostream::print(user_stream, *this, false); + } + + + +//! DEPRECATED FUNCTION +template +inline +void +Mat::impl_raw_print_trans(const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + Mat tmp; + op_strans::apply_noalias(tmp, *this); + + tmp.impl_raw_print(extra_text); + } + + + +//! DEPRECATED FUNCTION +template +inline +void +Mat::impl_raw_print_trans(std::ostream& user_stream, const std::string& extra_text) const + { + arma_extra_debug_sigprint(); + + Mat tmp; + op_strans::apply_noalias(tmp, *this); + + tmp.impl_raw_print(user_stream, extra_text); + } + + + +//! change the matrix to have user specified dimensions (data is not preserved) +template +inline +void +Mat::set_size(const uword in_elem) + { + arma_extra_debug_sigprint(); + + switch(vec_state) + { + case 0: + case 1: + init_warm(in_elem, 1); + break; + + case 2: + init_warm(1, in_elem); + break; + + default: + ; + } + } + + + +//! change the matrix to have user specified dimensions (data is not preserved) +template +inline +void +Mat::set_size(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + init_warm(in_rows, in_cols); + } + + + +//! change the matrix to have user specified dimensions (data is preserved) +template +inline +void +Mat::resize(const uword in_elem) + { + arma_extra_debug_sigprint(); + + switch(vec_state) + { + case 0: + case 1: + (*this).resize(in_elem, 1); + break; + + case 2: + (*this).resize(1, in_elem); + break; + + default: + ; + } + } + + + +//! change the matrix to have user specified dimensions (data is preserved) +template +inline +void +Mat::resize(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + *this = arma::resize(*this, in_rows, in_cols); + } + + + +//! change the matrix to have user specified dimensions (data is preserved) +template +inline +void +Mat::reshape(const uword in_rows, const uword in_cols, const uword dim) + { + arma_extra_debug_sigprint(); + + *this = arma::reshape(*this, in_rows, in_cols, dim); + } + + + +//! change the matrix (without preserving data) to have the same dimensions as the given matrix +template +template +inline +void +Mat::copy_size(const Mat& m) + { + arma_extra_debug_sigprint(); + + init_warm(m.n_rows, m.n_cols); + } + + + +//! fill the matrix with the specified value +template +arma_hot +inline +const Mat& +Mat::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( memptr(), val, n_elem ); + + return *this; + } + + + +template +inline +const Mat& +Mat::zeros() + { + arma_extra_debug_sigprint(); + + return fill(eT(0)); + } + + + +template +inline +const Mat& +Mat::zeros(const uword in_elem) + { + arma_extra_debug_sigprint(); + + set_size(in_elem); + + return fill(eT(0)); + } + + + +template +inline +const Mat& +Mat::zeros(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols); + + return fill(eT(0)); + } + + + +template +inline +const Mat& +Mat::ones() + { + arma_extra_debug_sigprint(); + + return fill(eT(1)); + } + + + +template +inline +const Mat& +Mat::ones(const uword in_elem) + { + arma_extra_debug_sigprint(); + + set_size(in_elem); + + return fill(eT(1)); + } + + + +template +inline +const Mat& +Mat::ones(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols); + + return fill(eT(1)); + } + + + +template +inline +const Mat& +Mat::randu() + { + arma_extra_debug_sigprint(); + + const uword N = n_elem; + eT* ptr = memptr(); + + uword i,j; + + for(i=0, j=1; j()); + const eT tmp_j = eT(eop_aux_randu()); + + ptr[i] = tmp_i; + ptr[j] = tmp_j; + } + + if(i < N) + { + ptr[i] = eT(eop_aux_randu()); + } + + return *this; + } + + + +template +inline +const Mat& +Mat::randu(const uword in_elem) + { + arma_extra_debug_sigprint(); + + set_size(in_elem); + + return (*this).randu(); + } + + + +template +inline +const Mat& +Mat::randu(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols); + + return (*this).randu(); + } + + + +template +inline +const Mat& +Mat::randn() + { + arma_extra_debug_sigprint(); + + const uword N = n_elem; + eT* ptr = memptr(); + + for(uword i=0; i()); + } + + return *this; + } + + + +template +inline +const Mat& +Mat::randn(const uword in_elem) + { + arma_extra_debug_sigprint(); + + set_size(in_elem); + + return (*this).randn(); + } + + + +template +inline +const Mat& +Mat::randn(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols); + + return (*this).randn(); + } + + + +template +inline +const Mat& +Mat::eye() + { + arma_extra_debug_sigprint(); + + fill(eT(0)); + + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i +inline +const Mat& +Mat::eye(const uword in_rows, const uword in_cols) + { + arma_extra_debug_sigprint(); + + set_size(in_rows, in_cols); + + return (*this).eye(); + } + + + +template +inline +void +Mat::reset() + { + arma_extra_debug_sigprint(); + + switch(vec_state) + { + default: + init_warm(0, 0); + break; + + case 1: + init_warm(0, 1); + break; + + case 2: + init_warm(1, 0); + break; + } + } + + + +template +template +inline +void +Mat::set_real(const Base::pod_type,T1>& X) + { + arma_extra_debug_sigprint(); + + Mat_aux::set_real(*this, X); + } + + + +template +template +inline +void +Mat::set_imag(const Base::pod_type,T1>& X) + { + arma_extra_debug_sigprint(); + + Mat_aux::set_imag(*this, X); + } + + + +template +inline +arma_warn_unused +eT +Mat::min() const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + return op_min::direct_min(memptr(), n_elem); + } + + + +template +inline +arma_warn_unused +eT +Mat::max() const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + return op_max::direct_max(memptr(), n_elem); + } + + + +template +inline +eT +Mat::min(uword& index_of_min_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + return op_min::direct_min(memptr(), n_elem, index_of_min_val); + } + + + +template +inline +eT +Mat::max(uword& index_of_max_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + return op_max::direct_max(memptr(), n_elem, index_of_max_val); + } + + + +template +inline +eT +Mat::min(uword& row_of_min_val, uword& col_of_min_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "min(): object has no elements" ); + + uword i; + + eT val = op_min::direct_min(memptr(), n_elem, i); + + row_of_min_val = i % n_rows; + col_of_min_val = i / n_rows; + + return val; + } + + + +template +inline +eT +Mat::max(uword& row_of_max_val, uword& col_of_max_val) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (n_elem == 0), "max(): object has no elements" ); + + uword i; + + eT val = op_max::direct_max(memptr(), n_elem, i); + + row_of_max_val = i % n_rows; + col_of_max_val = i / n_rows; + + return val; + } + + + +//! save the matrix to a file +template +inline +bool +Mat::save(const std::string name, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + bool save_okay; + + switch(type) + { + case raw_ascii: + save_okay = diskio::save_raw_ascii(*this, name); + break; + + case arma_ascii: + save_okay = diskio::save_arma_ascii(*this, name); + break; + + case csv_ascii: + save_okay = diskio::save_csv_ascii(*this, name); + break; + + case raw_binary: + save_okay = diskio::save_raw_binary(*this, name); + break; + + case arma_binary: + save_okay = diskio::save_arma_binary(*this, name); + break; + + case pgm_binary: + save_okay = diskio::save_pgm_binary(*this, name); + break; + + default: + arma_warn(print_status, "Mat::save(): unsupported file type"); + save_okay = false; + } + + arma_warn( (print_status && (save_okay == false)), "Mat::save(): couldn't write to ", name); + + return save_okay; + } + + + +//! save the matrix to a stream +template +inline +bool +Mat::save(std::ostream& os, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + bool save_okay; + + switch(type) + { + case raw_ascii: + save_okay = diskio::save_raw_ascii(*this, os); + break; + + case arma_ascii: + save_okay = diskio::save_arma_ascii(*this, os); + break; + + case csv_ascii: + save_okay = diskio::save_csv_ascii(*this, os); + break; + + case raw_binary: + save_okay = diskio::save_raw_binary(*this, os); + break; + + case arma_binary: + save_okay = diskio::save_arma_binary(*this, os); + break; + + case pgm_binary: + save_okay = diskio::save_pgm_binary(*this, os); + break; + + default: + arma_warn(print_status, "Mat::save(): unsupported file type"); + save_okay = false; + } + + arma_warn( (print_status && (save_okay == false)), "Mat::save(): couldn't write to the given stream"); + + return save_okay; + } + + + +//! load a matrix from a file +template +inline +bool +Mat::load(const std::string name, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + bool load_okay; + std::string err_msg; + + switch(type) + { + case auto_detect: + load_okay = diskio::load_auto_detect(*this, name, err_msg); + break; + + case raw_ascii: + load_okay = diskio::load_raw_ascii(*this, name, err_msg); + break; + + case arma_ascii: + load_okay = diskio::load_arma_ascii(*this, name, err_msg); + break; + + case csv_ascii: + load_okay = diskio::load_csv_ascii(*this, name, err_msg); + break; + + case raw_binary: + load_okay = diskio::load_raw_binary(*this, name, err_msg); + break; + + case arma_binary: + load_okay = diskio::load_arma_binary(*this, name, err_msg); + break; + + case pgm_binary: + load_okay = diskio::load_pgm_binary(*this, name, err_msg); + break; + + default: + arma_warn(print_status, "Mat::load(): unsupported file type"); + load_okay = false; + } + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "Mat::load(): ", err_msg, name); + } + else + { + arma_warn(true, "Mat::load(): couldn't read ", name); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +//! load a matrix from a stream +template +inline +bool +Mat::load(std::istream& is, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + bool load_okay; + std::string err_msg; + + switch(type) + { + case auto_detect: + load_okay = diskio::load_auto_detect(*this, is, err_msg); + break; + + case raw_ascii: + load_okay = diskio::load_raw_ascii(*this, is, err_msg); + break; + + case arma_ascii: + load_okay = diskio::load_arma_ascii(*this, is, err_msg); + break; + + case csv_ascii: + load_okay = diskio::load_csv_ascii(*this, is, err_msg); + break; + + case raw_binary: + load_okay = diskio::load_raw_binary(*this, is, err_msg); + break; + + case arma_binary: + load_okay = diskio::load_arma_binary(*this, is, err_msg); + break; + + case pgm_binary: + load_okay = diskio::load_pgm_binary(*this, is, err_msg); + break; + + default: + arma_warn(print_status, "Mat::load(): unsupported file type"); + load_okay = false; + } + + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "Mat::load(): ", err_msg, "the given stream"); + } + else + { + arma_warn(true, "Mat::load(): couldn't load from the given stream"); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +//! save the matrix to a file, without printing any error messages +template +inline +bool +Mat::quiet_save(const std::string name, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(name, type, false); + } + + + +//! save the matrix to a stream, without printing any error messages +template +inline +bool +Mat::quiet_save(std::ostream& os, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(os, type, false); + } + + + +//! load a matrix from a file, without printing any error messages +template +inline +bool +Mat::quiet_load(const std::string name, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(name, type, false); + } + + + +//! load a matrix from a stream, without printing any error messages +template +inline +bool +Mat::quiet_load(std::istream& is, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(is, type, false); + } + + + +template +inline +Mat::row_iterator::row_iterator(Mat& in_M, const uword in_row) + : M (in_M ) + , row(in_row) + , col(0 ) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +eT& +Mat::row_iterator::operator*() + { + return M.at(row,col); + } + + + +template +inline +typename Mat::row_iterator& +Mat::row_iterator::operator++() + { + ++col; + + if(col >= M.n_cols) + { + col = 0; + ++row; + } + + return *this; + } + + + +template +inline +void +Mat::row_iterator::operator++(int) + { + operator++(); + } + + + +template +inline +typename Mat::row_iterator& +Mat::row_iterator::operator--() + { + if(col > 0) + { + --col; + } + else + { + if(row > 0) + { + col = M.n_cols - 1; + --row; + } + } + + return *this; + } + + + +template +inline +void +Mat::row_iterator::operator--(int) + { + operator--(); + } + + + +template +inline +bool +Mat::row_iterator::operator!=(const typename Mat::row_iterator& X) const + { + return ( (row != X.row) || (col != X.col) ) ? true : false; + } + + + +template +inline +bool +Mat::row_iterator::operator==(const typename Mat::row_iterator& X) const + { + return ( (row == X.row) && (col == X.col) ) ? true : false; + } + + + +template +inline +Mat::const_row_iterator::const_row_iterator(const Mat& in_M, const uword in_row) + : M (in_M ) + , row(in_row) + , col(0 ) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Mat::const_row_iterator::const_row_iterator(const typename Mat::row_iterator& X) + : M (X.M) + , row(X.row) + , col(X.col) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +eT +Mat::const_row_iterator::operator*() const + { + return M.at(row,col); + } + + + +template +inline +typename Mat::const_row_iterator& +Mat::const_row_iterator::operator++() + { + ++col; + + if(col >= M.n_cols) + { + col = 0; + ++row; + } + + return *this; + } + + + +template +inline +void +Mat::const_row_iterator::operator++(int) + { + operator++(); + } + + + +template +inline +typename Mat::const_row_iterator& +Mat::const_row_iterator::operator--() + { + if(col > 0) + { + --col; + } + else + { + if(row > 0) + { + col = M.n_cols - 1; + --row; + } + } + + return *this; + } + + + +template +inline +void +Mat::const_row_iterator::operator--(int) + { + operator--(); + } + + + +template +inline +bool +Mat::const_row_iterator::operator!=(const typename Mat::const_row_iterator& X) const + { + return ( (row != X.row) || (col != X.col) ) ? true : false; + } + + + +template +inline +bool +Mat::const_row_iterator::operator==(const typename Mat::const_row_iterator& X) const + { + return ( (row == X.row) && (col == X.col) ) ? true : false; + } + + + +template +inline +typename Mat::iterator +Mat::begin() + { + arma_extra_debug_sigprint(); + + return memptr(); + } + + + +template +inline +typename Mat::const_iterator +Mat::begin() const + { + arma_extra_debug_sigprint(); + + return memptr(); + } + + + +template +inline +typename Mat::iterator +Mat::end() + { + arma_extra_debug_sigprint(); + + return memptr() + n_elem; + } + + + +template +inline +typename Mat::const_iterator +Mat::end() const + { + arma_extra_debug_sigprint(); + + return memptr() + n_elem; + } + + + +template +inline +typename Mat::col_iterator +Mat::begin_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "begin_col(): index out of bounds"); + + return colptr(col_num); + } + + + +template +inline +typename Mat::const_col_iterator +Mat::begin_col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "begin_col(): index out of bounds"); + + return colptr(col_num); + } + + + +template +inline +typename Mat::col_iterator +Mat::end_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "end_col(): index out of bounds"); + + return colptr(col_num) + n_rows; + } + + + +template +inline +typename Mat::const_col_iterator +Mat::end_col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "end_col(): index out of bounds"); + + return colptr(col_num) + n_rows; + } + + + +template +inline +typename Mat::row_iterator +Mat::begin_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "Mat::begin_row(): index out of bounds" ); + + return typename Mat::row_iterator(*this, row_num); + } + + + +template +inline +typename Mat::const_row_iterator +Mat::begin_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "Mat::begin_row(): index out of bounds" ); + + return typename Mat::const_row_iterator(*this, row_num); + } + + + +template +inline +typename Mat::row_iterator +Mat::end_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "Mat::end_row(): index out of bounds" ); + + return typename Mat::row_iterator(*this, row_num + 1); + } + + + +template +inline +typename Mat::const_row_iterator +Mat::end_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "Mat::end_row(): index out of bounds" ); + + return typename Mat::const_row_iterator(*this, row_num + 1); + } + + + +//! resets this matrix to an empty matrix +template +inline +void +Mat::clear() + { + reset(); + } + + + +//! returns true if the matrix has no elements +template +inline +bool +Mat::empty() const + { + return (n_elem == 0); + } + + + +//! returns the number of elements in this matrix +template +inline +uword +Mat::size() const + { + return n_elem; + } + + + +template +template +arma_inline +void +Mat::fixed::mem_setup() + { + arma_extra_debug_sigprint(); + + access::rw(Mat::n_rows) = fixed_n_rows; + access::rw(Mat::n_cols) = fixed_n_cols; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 0; + access::rw(Mat::mem_state) = 3; + access::rw(Mat::mem) = (use_extra) ? mem_local_extra : mem_local; + } + + + +template +template +arma_inline +Mat::fixed::fixed() + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + } + + + +template +template +arma_inline +Mat::fixed::fixed(const fixed& X) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + eT* dest = (use_extra) ? mem_local_extra : mem_local; + + arrayops::copy( dest, X.mem, fixed_n_elem ); + } + + + +template +template +template +inline +Mat::fixed::fixed(const Base& A) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Mat::operator=(A.get_ref()); + } + + + +template +template +template +inline +Mat::fixed::fixed(const Base& A, const Base& B) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Mat::init(A,B); + } + + + +template +template +inline +Mat::fixed::fixed(eT* aux_mem, const bool copy_aux_mem) + { + arma_extra_debug_sigprint_this(this); + + access::rw(Mat::n_rows) = fixed_n_rows; + access::rw(Mat::n_cols) = fixed_n_cols; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 0; + access::rw(Mat::mem_state) = 3; + + if(copy_aux_mem == true) + { + eT* dest = (use_extra) ? mem_local_extra : mem_local; + + access::rw(Mat::mem) = dest; + + arrayops::copy( dest, aux_mem, fixed_n_elem ); + } + else + { + access::rw(Mat::mem) = aux_mem; + } + } + + + +template +template +inline +Mat::fixed::fixed(const eT* aux_mem) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + arrayops::copy( const_cast(Mat::mem), aux_mem, fixed_n_elem ); + } + + + +template +template +inline +Mat::fixed::fixed(const char* text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Mat::operator=(text); + } + + + +template +template +inline +Mat::fixed::fixed(const std::string& text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Mat::operator=(text); + } + + + +template +template +template +inline +const Mat& +Mat::fixed::operator=(const Base& A) + { + Mat::operator=(A.get_ref()); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::fixed::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat::operator=(val); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::fixed::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + Mat::operator=(text); + + return *this; + } + + + +template +template +inline +const Mat& +Mat::fixed::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + Mat::operator=(text); + + return *this; + } + + + +template +template +inline +subview_row +Mat::fixed::operator()(const uword row_num, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +inline +const subview_row +Mat::fixed::operator()(const uword row_num, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +inline +subview_col +Mat::fixed::operator()(const span& row_span, const uword col_num) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +const subview_col +Mat::fixed::operator()(const span& row_span, const uword col_num) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +subview +Mat::fixed::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +inline +const subview +Mat::fixed::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Mat::fixed::operator[] (const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Mat::fixed::operator[] (const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Mat::fixed::at(const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Mat::fixed::at(const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Mat::fixed::operator() (const uword i) + { + arma_debug_check( (i >= fixed_n_elem), "Mat::fixed::operator(): out of bounds"); + + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Mat::fixed::operator() (const uword i) const + { + arma_debug_check( (i >= fixed_n_elem), "Mat::fixed::operator(): out of bounds"); + + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Mat::fixed::at(const uword in_row, const uword in_col) + { + const uword i = in_row + in_col*fixed_n_rows; + + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Mat::fixed::at(const uword in_row, const uword in_col) const + { + const uword i = in_row + in_col*fixed_n_rows; + + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Mat::fixed::operator() (const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= fixed_n_rows) || (in_col >= fixed_n_cols)), "Mat::fixed::operator(): out of bounds"); + + const uword i = in_row + in_col*fixed_n_rows; + + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Mat::fixed::operator() (const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= fixed_n_rows) || (in_col >= fixed_n_cols)), "Mat::fixed::operator(): out of bounds"); + + const uword i = in_row + in_col*fixed_n_rows; + + return ( Mat::mem[i] ); + } + + + +template +template +arma_hot +inline +const Mat& +Mat::fixed::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), val, fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Mat& +Mat::fixed::zeros() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(0), fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Mat& +Mat::fixed::ones() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(1), fixed_n_elem ); + + return *this; + } + + + +//! prefix ++ +template +arma_inline +void +Mat_aux::prefix_pp(Mat& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Mat_aux::prefix_pp(Mat< std::complex >& x) + { + x += T(1); + } + + + +//! postfix ++ +template +arma_inline +void +Mat_aux::postfix_pp(Mat& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Mat_aux::postfix_pp(Mat< std::complex >& x) + { + x += T(1); + } + + + +//! prefix -- +template +arma_inline +void +Mat_aux::prefix_mm(Mat& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Mat_aux::prefix_mm(Mat< std::complex >& x) + { + x -= T(1); + } + + + +//! postfix -- +template +arma_inline +void +Mat_aux::postfix_mm(Mat& x) + { + eT* memptr = x.memptr(); + const uword n_elem = x.n_elem; + + uword i,j; + + for(i=0, j=1; j +arma_inline +void +Mat_aux::postfix_mm(Mat< std::complex >& x) + { + x -= T(1); + } + + + +template +inline +void +Mat_aux::set_real(Mat& out, const Base& X) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + arma_debug_assert_same_size( out, A, "Mat::set_real()" ); + + out = A; + } + + + +template +inline +void +Mat_aux::set_imag(Mat& out, const Base& X) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +Mat_aux::set_real(Mat< std::complex >& out, const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename Proxy::ea_type ea_type; + + const Proxy A(X.get_ref()); + + arma_debug_assert_same_size( out, A, "Mat::set_real()" ); + + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + ea_type PA = A.get_ea(); + + for(uword i=0; i( PA[i], out_mem[i].imag() ); + } + } + + + +template +inline +void +Mat_aux::set_imag(Mat< std::complex >& out, const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename Proxy::ea_type ea_type; + + const Proxy A(X.get_ref()); + + arma_debug_assert_same_size( out, A, "Mat::set_imag()" ); + + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + ea_type PA = A.get_ea(); + + for(uword i=0; i( out_mem[i].real(), PA[i] ); + } + } + + + +#ifdef ARMA_EXTRA_MAT_MEAT + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_MAT_MEAT) +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/OpCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/OpCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,48 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup OpCube +//! @{ + + +//! Analog of the Op class, intended for cubes + +template +class OpCube : public BaseCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + + inline explicit OpCube(const BaseCube& in_m); + inline OpCube(const BaseCube& in_m, const elem_type in_aux); + inline OpCube(const BaseCube& in_m, const elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + inline OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + inline OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c, const uword in_aux_uword_d, const char junk); + inline ~OpCube(); + + arma_aligned const T1& m; //!< storage of reference to the operand (e.g. a cube) + arma_aligned elem_type aux; //!< storage of auxiliary data, user defined format + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_c; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_d; //!< storage of auxiliary data, uword format + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/OpCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/OpCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,95 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup OpCube +//! @{ + + + +template +OpCube::OpCube(const BaseCube& in_m) + : m(in_m.get_ref()) + { + arma_extra_debug_sigprint(); + } + + + +template +OpCube::OpCube(const BaseCube& in_m, const typename T1::elem_type in_aux) + : m(in_m.get_ref()) + , aux(in_aux) + { + arma_extra_debug_sigprint(); + } + + +template +OpCube::OpCube(const BaseCube& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : m(in_m.get_ref()) + , aux(in_aux) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + + +template +OpCube::OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b) + : m(in_m.get_ref()) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +OpCube::OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : m(in_m.get_ref()) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +OpCube::OpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c, const uword in_aux_uword_d, const char) + : m(in_m.get_ref()) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + , aux_uword_d(in_aux_uword_d) + { + arma_extra_debug_sigprint(); + } + + + +template +OpCube::~OpCube() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Op_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Op_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,55 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Op +//! @{ + + + +//! Class for storing data required for delayed unary operations, +//! such as the operand (e.g. the matrix to which the operation is to be applied) and the unary operator (e.g. inverse). +//! The operand is stored as a reference (which can be optimised away), +//! while the operator is "stored" through the template definition (op_type). +//! The operands can be 'Mat', 'Row', 'Col', 'Op', and 'Glue'. +//! Note that as 'Glue' can be one of the operands, more than one matrix can be stored. +//! +//! For example, we could have: +//! Op< Glue< Mat, Mat, glue_times >, op_htrans > + +template +class Op : public Base > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + inline explicit Op(const T1& in_m); + inline Op(const T1& in_m, const elem_type in_aux); + inline Op(const T1& in_m, const elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline Op(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline Op(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c, const char junk); + inline ~Op(); + + + arma_aligned const T1& m; //!< storage of reference to the operand (eg. a matrix) + arma_aligned elem_type aux; //!< storage of auxiliary data, user defined format + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_c; //!< storage of auxiliary data, uword format + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Op_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Op_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,87 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Op +//! @{ + + + +template +inline +Op::Op(const T1& in_m) + : m(in_m) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Op::Op(const T1& in_m, const typename T1::elem_type in_aux) + : m(in_m) + , aux(in_aux) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Op::Op(const T1& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b) + : m(in_m) + , aux(in_aux) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Op::Op(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b) + : m(in_m) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Op::Op(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c, const char) + : m(in_m) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +Op::~Op() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Proxy.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Proxy.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,503 @@ +// Copyright (C) 2010-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Proxy +//! @{ + + + +template +class Proxy + { + public: + inline Proxy(const T1& A) + { + arma_type_check(( is_arma_type::value == false )); + } + }; + + + +// ea_type is the "element accessor" type, +// which can provide access to elements via operator[] + +template +class Proxy< Mat > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat& Q; + + inline explicit Proxy(const Mat& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&Q) == void_ptr(&X)); } + }; + + + +template +class Proxy< Col > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Col stored_type; + typedef const eT* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Col& Q; + + inline explicit Proxy(const Col& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&Q) == void_ptr(&X)); } + }; + + + +template +class Proxy< Row > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Row stored_type; + typedef const eT* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Row& Q; + + inline explicit Proxy(const Row& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return 1; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&Q) == void_ptr(&X)); } + }; + + + +template +class Proxy< Gen > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Gen stored_type; + typedef const Gen& ea_type; + + static const bool prefer_at_accessor = Gen::prefer_at_accessor; + static const bool has_subview = false; + + arma_aligned const Gen& Q; + + inline explicit Proxy(const Gen& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_rows*Q.n_cols; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +template +class Proxy< Op > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const Op& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +template +class Proxy< Glue > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const Glue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +template +class Proxy< subview > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview stored_type; + typedef const subview& ea_type; + + static const bool prefer_at_accessor = true; + static const bool has_subview = true; + + arma_aligned const subview& Q; + + inline explicit Proxy(const subview& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.m)) == void_ptr(&X)); } + }; + + + +template +class Proxy< subview_elem1 > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const eT* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const subview_elem1& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +template +class Proxy< diagview > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef diagview stored_type; + typedef const diagview& ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = true; + + arma_aligned const diagview& Q; + + inline explicit Proxy(const diagview& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return 1; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (void_ptr(&(Q.m)) == void_ptr(&X)); } + }; + + + + +template +class Proxy< eOp > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eOp stored_type; + typedef const eOp& ea_type; + + static const bool prefer_at_accessor = eOp::prefer_at_accessor; + static const bool has_subview = eOp::has_subview; + + arma_aligned const eOp& Q; + + inline explicit Proxy(const eOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return Q.get_n_cols(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return Q.P.is_alias(X); } + }; + + + +template +class Proxy< eGlue > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eGlue stored_type; + typedef const eGlue& ea_type; + + static const bool prefer_at_accessor = eGlue::prefer_at_accessor; + static const bool has_subview = eGlue::has_subview; + + arma_aligned const eGlue& Q; + + inline explicit Proxy(const eGlue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return Q.get_n_cols(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row, col); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Mat& X) const { return (Q.P1.is_alias(X) || Q.P2.is_alias(X)); } + }; + + + +template +class Proxy< mtOp > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const mtOp& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row,col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +template +class Proxy< mtGlue > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Mat stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Mat Q; + + inline explicit Proxy(const mtGlue& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return Q.at(row,col); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Mat&) const { return false; } + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/ProxyCube.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/ProxyCube.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,376 @@ +// Copyright (C) 2010-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup ProxyCube +//! @{ + + + +template +class ProxyCube + { + public: + inline ProxyCube(const T1& A) + { + arma_type_check(( is_arma_cube_type::value == false )); + } + }; + + + +// ea_type is the "element accessor" type, +// which can provide access to elements via operator[] + +template +class ProxyCube< Cube > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Cube stored_type; + typedef const eT* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Cube& Q; + + inline explicit ProxyCube(const Cube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Cube& X) const { return (void_ptr(&Q) == void_ptr(&X)); } + }; + + + +template +class ProxyCube< GenCube > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef GenCube stored_type; + typedef const GenCube& ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const GenCube& Q; + + inline explicit ProxyCube(const GenCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_rows*Q.n_cols; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_rows*Q.n_cols*Q.n_slices; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Cube&) const { return false; } + }; + + + +template +class ProxyCube< OpCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Cube stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Cube Q; + + inline explicit ProxyCube(const OpCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Cube&) const { return false; } + }; + + + +template +class ProxyCube< GlueCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Cube stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Cube Q; + + inline explicit ProxyCube(const GlueCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Cube&) const { return false; } + }; + + + +template +class ProxyCube< subview_cube > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef subview_cube stored_type; + typedef const subview_cube& ea_type; + + static const bool prefer_at_accessor = true; + static const bool has_subview = true; + + arma_aligned const subview_cube& Q; + + inline explicit ProxyCube(const subview_cube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Cube& X) const { return (void_ptr(&(Q.m)) == void_ptr(&X)); } + }; + + + +template +class ProxyCube< eOpCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eOpCube stored_type; + typedef const eOpCube& ea_type; + + static const bool prefer_at_accessor = eOpCube::prefer_at_accessor; + static const bool has_subview = eOpCube::has_subview; + + arma_aligned const eOpCube& Q; + + inline explicit ProxyCube(const eOpCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return Q.get_n_cols(); } + arma_inline uword get_n_elem_slice() const { return Q.get_n_elem_slice(); } + arma_inline uword get_n_slices() const { return Q.get_n_slices(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Cube& X) const { return Q.P.is_alias(X); } + }; + + + +template +class ProxyCube< eGlueCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef eGlueCube stored_type; + typedef const eGlueCube& ea_type; + + static const bool prefer_at_accessor = eGlueCube::prefer_at_accessor; + static const bool has_subview = eGlueCube::has_subview; + + arma_aligned const eGlueCube& Q; + + inline explicit ProxyCube(const eGlueCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.get_n_rows(); } + arma_inline uword get_n_cols() const { return Q.get_n_cols(); } + arma_inline uword get_n_elem_slice() const { return Q.get_n_elem_slice(); } + arma_inline uword get_n_slices() const { return Q.get_n_slices(); } + arma_inline uword get_n_elem() const { return Q.get_n_elem(); } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q; } + + template + arma_inline bool is_alias(const Cube& X) const { return (Q.P1.is_alias(X) || Q.P2.is_alias(X)); } + }; + + + +template +class ProxyCube< mtOpCube > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Cube stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Cube Q; + + inline explicit ProxyCube(const mtOpCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Cube&) const { return false; } + }; + + + +template +class ProxyCube< mtGlueCube > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + typedef Cube stored_type; + typedef const elem_type* ea_type; + + static const bool prefer_at_accessor = false; + static const bool has_subview = false; + + arma_aligned const Cube Q; + + inline explicit ProxyCube(const mtGlueCube& A) + : Q(A) + { + arma_extra_debug_sigprint(); + } + + arma_inline uword get_n_rows() const { return Q.n_rows; } + arma_inline uword get_n_cols() const { return Q.n_cols; } + arma_inline uword get_n_elem_slice() const { return Q.n_elem_slice; } + arma_inline uword get_n_slices() const { return Q.n_slices; } + arma_inline uword get_n_elem() const { return Q.n_elem; } + + arma_inline elem_type operator[] (const uword i) const { return Q[i]; } + arma_inline elem_type at (const uword row, const uword col, const uword slice) const { return Q.at(row, col, slice); } + + arma_inline ea_type get_ea() const { return Q.memptr(); } + + template + arma_inline bool is_alias(const Cube&) const { return false; } + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Row_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Row_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,169 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Row +//! @{ + +//! Class for row vectors (matrices with only one row) + +template +class Row : public Mat + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline Row(); + inline Row(const Row& X); + inline explicit Row(const uword N); + inline Row(const uword in_rows, const uword in_cols); + + inline Row(const char* text); + inline const Row& operator=(const char* text); + + inline Row(const std::string& text); + inline const Row& operator=(const std::string& text); + + #if defined(ARMA_USE_CXX11) + inline Row(const std::initializer_list& list); + inline const Row& operator=(const std::initializer_list& list); + #endif + + inline const Row& operator=(const eT val); + + template inline Row(const Base& X); + template inline const Row& operator=(const Base& X); + + inline Row( eT* aux_mem, const uword aux_length, const bool copy_aux_mem = true, const bool strict = true); + inline Row(const eT* aux_mem, const uword aux_length); + + template + inline explicit Row(const Base& A, const Base& B); + + template inline Row(const BaseCube& X); + template inline const Row& operator=(const BaseCube& X); + + inline Row(const subview_cube& X); + inline const Row& operator=(const subview_cube& X); + + inline mat_injector operator<<(const eT val); + + arma_inline eT& col(const uword col_num); + arma_inline eT col(const uword col_num) const; + + arma_inline subview_row cols(const uword in_col1, const uword in_col2); + arma_inline const subview_row cols(const uword in_col1, const uword in_col2) const; + + arma_inline subview_row subvec(const uword in_col1, const uword in_col2); + arma_inline const subview_row subvec(const uword in_col1, const uword in_col2) const; + + arma_inline subview_row subvec(const span& col_span); + arma_inline const subview_row subvec(const span& col_span) const; + + // arma_inline subview_row operator()(const span& col_span); + // arma_inline const subview_row operator()(const span& col_span) const; + + + inline void shed_col (const uword col_num); + inline void shed_cols(const uword in_col1, const uword in_col2); + + inline void insert_cols(const uword col_num, const uword N, const bool set_to_zero = true); + template inline void insert_cols(const uword col_num, const Base& X); + + + typedef eT* row_iterator; + typedef const eT* const_row_iterator; + + inline row_iterator begin_row(const uword row_num); + inline const_row_iterator begin_row(const uword row_num) const; + + inline row_iterator end_row (const uword row_num); + inline const_row_iterator end_row (const uword row_num) const; + + + template + class fixed : public Row + { + private: + + static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc); + + arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; + + arma_inline void mem_setup(); + + + public: + + static const uword n_rows = 1; + static const uword n_cols = fixed_n_elem; + static const uword n_elem = fixed_n_elem; + + arma_inline fixed(); + arma_inline fixed(const fixed& X); + inline fixed(const subview_cube& X); + + template inline fixed(const Base& A); + template inline fixed(const Base& A, const Base& B); + + inline fixed( eT* aux_mem, const bool copy_aux_mem = true); + inline fixed(const eT* aux_mem); + + inline fixed(const char* text); + inline fixed(const std::string& text); + + template inline const Row& operator=(const Base& A); + + inline const Row& operator=(const eT val); + inline const Row& operator=(const char* text); + inline const Row& operator=(const std::string& text); + inline const Row& operator=(const subview_cube& X); + + inline subview_row operator()(const uword row_num, const span& col_span); + inline const subview_row operator()(const uword row_num, const span& col_span) const; + + inline subview_col operator()(const span& row_span, const uword col_num ); + inline const subview_col operator()(const span& row_span, const uword col_num ) const; + + inline subview operator()(const span& row_span, const span& col_span); + inline const subview operator()(const span& row_span, const span& col_span) const; + + arma_inline arma_warn_unused eT& operator[] (const uword i); + arma_inline arma_warn_unused eT operator[] (const uword i) const; + arma_inline arma_warn_unused eT& at (const uword i); + arma_inline arma_warn_unused eT at (const uword i) const; + arma_inline arma_warn_unused eT& operator() (const uword i); + arma_inline arma_warn_unused eT operator() (const uword i) const; + + arma_inline arma_warn_unused eT& at (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT at (const uword in_row, const uword in_col) const; + arma_inline arma_warn_unused eT& operator() (const uword in_row, const uword in_col); + arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; + + arma_hot inline const Row& fill(const eT val); + arma_hot inline const Row& zeros(); + arma_hot inline const Row& ones(); + }; + + + #ifdef ARMA_EXTRA_ROW_PROTO + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_PROTO) + #endif + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/Row_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/Row_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1125 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup Row +//! @{ + + +//! construct an empty row vector +template +inline +Row::Row() + : Mat(1, 0) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + } + + + +template +inline +Row::Row(const Row& X) + : Mat(1, X.n_elem) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + arrayops::copy((*this).memptr(), X.memptr(), X.n_elem); + } + + + +//! construct a row vector with the specified number of n_elem +template +inline +Row::Row(const uword in_n_elem) + : Mat(1, in_n_elem) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + } + + + +template +inline +Row::Row(const uword in_n_rows, const uword in_n_cols) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::init_warm(in_n_rows, in_n_cols); + } + + + +template +inline +Row::Row(const char* text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + } + + + +template +inline +const Row& +Row::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + Mat::operator=(text); + + return *this; + } + + + +template +inline +Row::Row(const std::string& text) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(text); + } + + + +template +inline +const Row& +Row::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + Mat::operator=(text); + + return *this; + } + + + +#if defined(ARMA_USE_CXX11) + +template +inline +Row::Row(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(list); + } + + + +template +inline +const Row& +Row::operator=(const std::initializer_list& list) + { + arma_extra_debug_sigprint(); + + Mat::operator=(list); + + return *this; + } + +#endif + + + +template +inline +const Row& +Row::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat::operator=(val); + + return *this; + } + + + +template +template +inline +Row::Row(const Base& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(X.get_ref()); + } + + + +template +template +inline +const Row& +Row::operator=(const Base& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X.get_ref()); + + return *this; + } + + + +//! construct a row vector from a given auxiliary array +template +inline +Row::Row(eT* aux_mem, const uword aux_length, const bool copy_aux_mem, const bool strict) + : Mat(aux_mem, 1, aux_length, copy_aux_mem, strict) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + } + + + +//! construct a row vector from a given auxiliary array +template +inline +Row::Row(const eT* aux_mem, const uword aux_length) + : Mat(aux_mem, 1, aux_length) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + } + + + +template +template +inline +Row::Row + ( + const Base::pod_type, T1>& A, + const Base::pod_type, T2>& B + ) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::init(A,B); + } + + + +template +template +inline +Row::Row(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(X); + } + + + +template +template +inline +const Row& +Row::operator=(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X); + + return *this; + } + + + +template +inline +Row::Row(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + access::rw(Mat::vec_state) = 2; + + Mat::operator=(X); + } + + + +template +inline +const Row& +Row::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + Mat::operator=(X); + + return *this; + } + + + +template +inline +mat_injector< Row > +Row::operator<<(const eT val) + { + return mat_injector< Row >(*this, val); + } + + + +template +arma_inline +eT& +Row::col(const uword col_num) + { + arma_debug_check( (col_num >= Mat::n_cols), "Row::col(): out of bounds" ); + + return access::rw(Mat::mem[col_num]); + } + + + +template +arma_inline +eT +Row::col(const uword col_num) const + { + arma_debug_check( (col_num >= Mat::n_cols), "Row::col(): out of bounds" ); + + return Mat::mem[col_num]; + } + + + +template +arma_inline +subview_row +Row::cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat::n_cols) ), "Row::cols(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview_row(*this, 0, in_col1, subview_n_cols); + } + + + +template +arma_inline +const subview_row +Row::cols(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat::n_cols) ), "Row::cols(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview_row(*this, 0, in_col1, subview_n_cols); + } + + + +template +arma_inline +subview_row +Row::subvec(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat::n_cols) ), "Row::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview_row(*this, 0, in_col1, subview_n_cols); + } + + + +template +arma_inline +const subview_row +Row::subvec(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= Mat::n_cols) ), "Row::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + return subview_row(*this, 0, in_col1, subview_n_cols); + } + + + +template +arma_inline +subview_row +Row::subvec(const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = Mat::n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword subvec_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check( ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ), "Row::subvec(): indices out of bounds or incorrectly used"); + + return subview_row(*this, 0, in_col1, subvec_n_cols); + } + + + +template +arma_inline +const subview_row +Row::subvec(const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = Mat::n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword subvec_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check( ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ), "Row::subvec(): indices out of bounds or incorrectly used"); + + return subview_row(*this, 0, in_col1, subvec_n_cols); + } + + + +// template +// arma_inline +// subview_row +// Row::operator()(const span& col_span) +// { +// arma_extra_debug_sigprint(); +// +// return subvec(col_span); +// } +// +// +// +// template +// arma_inline +// const subview_row +// Row::operator()(const span& col_span) const +// { +// arma_extra_debug_sigprint(); +// +// return subvec(col_span); +// } + + + +//! remove specified columns +template +inline +void +Row::shed_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= Mat::n_cols, "Row::shed_col(): out of bounds"); + + shed_cols(col_num, col_num); + } + + + +//! remove specified columns +template +inline +void +Row::shed_cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= Mat::n_cols), + "Row::shed_cols(): indices out of bounds or incorrectly used" + ); + + const uword n_keep_front = in_col1; + const uword n_keep_back = Mat::n_cols - (in_col2 + 1); + + Row X(n_keep_front + n_keep_back); + + eT* X_mem = X.memptr(); + const eT* t_mem = (*this).memptr(); + + if(n_keep_front > 0) + { + arrayops::copy( X_mem, t_mem, n_keep_front ); + } + + if(n_keep_back > 0) + { + arrayops::copy( &(X_mem[n_keep_front]), &(t_mem[in_col2+1]), n_keep_back); + } + + Mat::steal_mem(X); + } + + + +//! insert N cols at the specified col position, +//! optionally setting the elements of the inserted cols to zero +template +inline +void +Row::insert_cols(const uword col_num, const uword N, const bool set_to_zero) + { + arma_extra_debug_sigprint(); + + const uword t_n_cols = Mat::n_cols; + + const uword A_n_cols = col_num; + const uword B_n_cols = t_n_cols - col_num; + + // insertion at col_num == n_cols is in effect an append operation + arma_debug_check( (col_num > t_n_cols), "Row::insert_cols(): out of bounds"); + + if(N > 0) + { + Row out(t_n_cols + N); + + eT* out_mem = out.memptr(); + const eT* t_mem = (*this).memptr(); + + if(A_n_cols > 0) + { + arrayops::copy( out_mem, t_mem, A_n_cols ); + } + + if(B_n_cols > 0) + { + arrayops::copy( &(out_mem[col_num + N]), &(t_mem[col_num]), B_n_cols ); + } + + if(set_to_zero == true) + { + arrayops::inplace_set( &(out_mem[col_num]), eT(0), N ); + } + + Mat::steal_mem(out); + } + } + + + +//! insert the given object at the specified col position; +//! the given object must have one row +template +template +inline +void +Row::insert_cols(const uword col_num, const Base& X) + { + arma_extra_debug_sigprint(); + + Mat::insert_cols(col_num, X); + } + + + +template +inline +typename Row::row_iterator +Row::begin_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "begin_row(): index out of bounds"); + + return Mat::memptr(); + } + + + +template +inline +typename Row::const_row_iterator +Row::begin_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "begin_row(): index out of bounds"); + + return Mat::memptr(); + } + + + +template +inline +typename Row::row_iterator +Row::end_row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "end_row(): index out of bounds"); + + return Mat::memptr() + Mat::n_cols; + } + + + +template +inline +typename Row::const_row_iterator +Row::end_row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= Mat::n_rows), "end_row(): index out of bounds"); + + return Mat::memptr() + Mat::n_cols; + } + + + +template +template +arma_inline +void +Row::fixed::mem_setup() + { + arma_extra_debug_sigprint(); + + access::rw(Mat::n_rows) = 1; + access::rw(Mat::n_cols) = fixed_n_elem; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 2; + access::rw(Mat::mem_state) = 3; + access::rw(Mat::mem) = (use_extra) ? mem_local_extra : Mat::mem_local; + } + + + +template +template +inline +Row::fixed::fixed() + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + } + + + +template +template +arma_inline +Row::fixed::fixed(const fixed& X) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + eT* dest = (use_extra) ? mem_local_extra : Mat::mem_local; + + arrayops::copy( dest, X.mem, fixed_n_elem ); + } + + + +template +template +arma_inline +Row::fixed::fixed(const subview_cube& X) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Row::operator=(X); + } + + + +template +template +template +arma_inline +Row::fixed::fixed(const Base& A) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Row::operator=(A.get_ref()); + } + + + +template +template +template +arma_inline +Row::fixed::fixed(const Base& A, const Base& B) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Row::init(A,B); + } + + + +template +template +inline +Row::fixed::fixed(eT* aux_mem, const bool copy_aux_mem) + { + arma_extra_debug_sigprint_this(this); + + access::rw(Mat::n_rows) = 1; + access::rw(Mat::n_cols) = fixed_n_elem; + access::rw(Mat::n_elem) = fixed_n_elem; + access::rw(Mat::vec_state) = 2; + access::rw(Mat::mem_state) = 3; + + if(copy_aux_mem == true) + { + eT* dest = (use_extra) ? mem_local_extra : Mat::mem_local; + + access::rw(Mat::mem) = dest; + + arrayops::copy( dest, aux_mem, fixed_n_elem ); + } + else + { + access::rw(Mat::mem) = aux_mem; + } + } + + + +template +template +inline +Row::fixed::fixed(const eT* aux_mem) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + arrayops::copy( const_cast(Mat::mem), aux_mem, fixed_n_elem ); + } + + + +template +template +inline +Row::fixed::fixed(const char* text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Row::operator=(text); + } + + + +template +template +inline +Row::fixed::fixed(const std::string& text) + { + arma_extra_debug_sigprint_this(this); + + mem_setup(); + + Row::operator=(text); + } + + + +template +template +inline +subview_row +Row::fixed::operator()(const uword row_num, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +template +const Row& +Row::fixed::operator=(const Base& A) + { + arma_extra_debug_sigprint(); + + Row::operator=(A.get_ref()); + + return *this; + } + + + +template +template +const Row& +Row::fixed::operator=(const eT val) + { + arma_extra_debug_sigprint(); + + Row::operator=(val); + + return *this; + } + + + +template +template +const Row& +Row::fixed::operator=(const char* text) + { + arma_extra_debug_sigprint(); + + Row::operator=(text); + + return *this; + } + + + +template +template +const Row& +Row::fixed::operator=(const std::string& text) + { + arma_extra_debug_sigprint(); + + Row::operator=(text); + + return *this; + } + + + +template +template +const Row& +Row::fixed::operator=(const subview_cube& X) + { + arma_extra_debug_sigprint(); + + Row::operator=(X); + + return *this; + } + + + +template +template +inline +const subview_row +Row::fixed::operator()(const uword row_num, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_num, col_span); + } + + + +template +template +inline +subview_col +Row::fixed::operator()(const span& row_span, const uword col_num) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +const subview_col +Row::fixed::operator()(const span& row_span, const uword col_num) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_num); + } + + + +template +template +inline +subview +Row::fixed::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +inline +const subview +Row::fixed::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return Mat::operator()(row_span, col_span); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Row::fixed::operator[] (const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Row::fixed::operator[] (const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Row::fixed::at(const uword i) + { + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Row::fixed::at(const uword i) const + { + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Row::fixed::operator() (const uword i) + { + arma_debug_check( (i >= fixed_n_elem), "Row::fixed::operator(): out of bounds"); + + return access::rw( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Row::fixed::operator() (const uword i) const + { + arma_debug_check( (i >= fixed_n_elem), "Row::fixed::operator(): out of bounds"); + + return ( Mat::mem[i] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Row::fixed::at(const uword in_row, const uword in_col) + { + return access::rw( Mat::mem[in_col] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Row::fixed::at(const uword in_row, const uword in_col) const + { + return ( Mat::mem[in_col] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT& +Row::fixed::operator() (const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= 1) || (in_col >= fixed_n_elem)), "Row::fixed::operator(): out of bounds" ); + + return access::rw( Mat::mem[in_col] ); + } + + + +template +template +arma_inline +arma_warn_unused +eT +Row::fixed::operator() (const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= 1) || (in_col >= fixed_n_elem)), "Row::fixed::operator(): out of bounds" ); + + return ( Mat::mem[in_col] ); + } + + + +template +template +arma_hot +inline +const Row& +Row::fixed::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), val, fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Row& +Row::fixed::zeros() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(0), fixed_n_elem ); + + return *this; + } + + + +template +template +arma_hot +inline +const Row& +Row::fixed::ones() + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set( const_cast(Mat::mem), eT(1), fixed_n_elem ); + + return *this; + } + + + +#ifdef ARMA_EXTRA_ROW_MEAT + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_MEAT) +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/access.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/access.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,31 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup access +//! @{ + + +class access + { + public: + + //! internal function to allow modification of data declared as read-only + template arma_inline static T1& rw(const T1& x) { return const_cast(x); } + + //! internal function to obtain the real part of either a plain number or a complex number + template arma_inline static const eT& tmp_real(const eT& X) { return X; } + template arma_inline static const T tmp_real(const std::complex& X) { return X.real(); } + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arma_config.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arma_config.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,98 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arma_config +//! @{ + + + +struct arma_config + { + #if defined(ARMA_MAT_PREALLOC) + static const uword mat_prealloc = (sword(ARMA_MAT_PREALLOC) > 0) ? uword(ARMA_MAT_PREALLOC) : 1; + #else + static const uword mat_prealloc = 16; + #endif + + #if defined(ARMA_USE_ATLAS) + static const bool atlas = true; + #else + static const bool atlas = false; + #endif + + + #if defined(ARMA_USE_LAPACK) + static const bool lapack = true; + #else + static const bool lapack = false; + #endif + + + #if defined(ARMA_USE_BLAS) + static const bool blas = true; + #else + static const bool blas = false; + #endif + + + #if defined(ARMA_USE_BOOST) + static const bool boost = true; + #else + static const bool boost = false; + #endif + + + #if defined(ARMA_USE_BOOST_DATE) + static const bool boost_date = true; + #else + static const bool boost_date = false; + #endif + + + #if !defined(ARMA_NO_DEBUG) && !defined(NDEBUG) + static const bool debug = true; + #else + static const bool debug = false; + #endif + + + #if defined(ARMA_EXTRA_DEBUG) + static const bool extra_debug = true; + #else + static const bool extra_debug = false; + #endif + + + #if defined(ARMA_GOOD_COMPILER) + static const bool good_comp = true; + #else + static const bool good_comp = false; + #endif + + + #if ( \ + defined(ARMA_EXTRA_MAT_PROTO) || defined(ARMA_EXTRA_MAT_MEAT) \ + || defined(ARMA_EXTRA_COL_PROTO) || defined(ARMA_EXTRA_COL_MEAT) \ + || defined(ARMA_EXTRA_ROW_PROTO) || defined(ARMA_EXTRA_ROW_MEAT) \ + || defined(ARMA_EXTRA_CUBE_PROTO) || defined(ARMA_EXTRA_CUBE_MEAT) \ + || defined(ARMA_EXTRA_FIELD_PROTO) || defined(ARMA_EXTRA_FIELD_MEAT) \ + ) + static const bool extra_code = true; + #else + static const bool extra_code = false; + #endif + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arma_ostream_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arma_ostream_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,59 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arma_ostream +//! @{ + + + +class arma_ostream_state + { + private: + + const ios::fmtflags orig_flags; + const std::streamsize orig_precision; + const std::streamsize orig_width; + const char orig_fill; + + + public: + + inline arma_ostream_state(const std::ostream& o); + + inline void restore(std::ostream& o) const; + }; + + + +class arma_ostream + { + public: + + template inline static std::streamsize modify_stream(std::ostream& o, const eT* data, const uword n_elem); + template inline static std::streamsize modify_stream(std::ostream& o, const std::complex* data, const uword n_elem); + + template inline static void print_elem_zero(std::ostream& o); + + template arma_inline static void print_elem(std::ostream& o, const eT& x); + template inline static void print_elem(std::ostream& o, const std::complex& x); + + template inline static void print(std::ostream& o, const Mat& m, const bool modify); + template inline static void print(std::ostream& o, const Cube& m, const bool modify); + + template inline static void print(std::ostream& o, const field& m); + template inline static void print(std::ostream& o, const subview_field& m); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arma_ostream_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arma_ostream_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,374 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arma_ostream +//! @{ + + + +inline +arma_ostream_state::arma_ostream_state(const std::ostream& o) + : orig_flags (o.flags()) + , orig_precision(o.precision()) + , orig_width (o.width()) + , orig_fill (o.fill()) + { + } + + + +inline +void +arma_ostream_state::restore(std::ostream& o) const + { + o.flags (orig_flags); + o.precision(orig_precision); + o.width (orig_width); + o.fill (orig_fill); + } + + + +// +// + + + +template +inline +std::streamsize +arma_ostream::modify_stream(std::ostream& o, const eT* data, const uword n_elem) + { + o.unsetf(ios::showbase); + o.unsetf(ios::uppercase); + o.unsetf(ios::showpos); + + o.fill(' '); + + std::streamsize cell_width; + + bool use_layout_B = false; + bool use_layout_C = false; + + for(uword i=0; i= eT(+100) || + ( (is_signed::value == true) && (val <= eT(-100)) ) || + ( (is_non_integral::value == true) && (val > eT(0)) && (val <= eT(+1e-4)) ) || + ( (is_non_integral::value == true) && (is_signed::value == true) && (val < eT(0)) && (val >= eT(-1e-4)) ) + ) + { + use_layout_C = true; + break; + } + + if( + (val >= eT(+10)) || ( (is_signed::value == true) && (val <= eT(-10)) ) + ) + { + use_layout_B = true; + } + } + + if(use_layout_C == true) + { + o.setf(ios::scientific); + o.setf(ios::right); + o.unsetf(ios::fixed); + o.precision(4); + cell_width = 13; + } + else + if(use_layout_B == true) + { + o.unsetf(ios::scientific); + o.setf(ios::right); + o.setf(ios::fixed); + o.precision(4); + cell_width = 10; + } + else + { + o.unsetf(ios::scientific); + o.setf(ios::right); + o.setf(ios::fixed); + o.precision(4); + cell_width = 9; + } + + return cell_width; + } + + + +//! "better than nothing" settings for complex numbers +template +inline +std::streamsize +arma_ostream::modify_stream(std::ostream& o, const std::complex* data, const uword n_elem) + { + arma_ignore(data); + arma_ignore(n_elem); + + o.unsetf(ios::showbase); + o.unsetf(ios::uppercase); + o.fill(' '); + + o.setf(ios::scientific); + o.setf(ios::showpos); + o.setf(ios::right); + o.unsetf(ios::fixed); + + std::streamsize cell_width; + + o.precision(3); + cell_width = 2 + 2*(1 + 3 + o.precision() + 5) + 1; + + return cell_width; + } + + + +template +inline +void +arma_ostream::print_elem_zero(std::ostream& o) + { + const std::streamsize orig_precision = o.precision(); + + o.precision(0); + + o << eT(0); + + o.precision(orig_precision); + } + + + +//! Print an element to the specified stream +template +arma_inline +void +arma_ostream::print_elem(std::ostream& o, const eT& x) + { + if(x != eT(0)) + { + o << x; + } + else + { + arma_ostream::print_elem_zero(o); + } + } + + + +//! Print a complex element to the specified stream +template +inline +void +arma_ostream::print_elem(std::ostream& o, const std::complex& x) + { + if( (x.real() != T(0)) || (x.imag() != T(0)) ) + { + std::ostringstream ss; + ss.flags(o.flags()); + //ss.imbue(o.getloc()); + ss.precision(o.precision()); + + ss << '(' << x.real() << ',' << x.imag() << ')'; + o << ss.str(); + } + else + { + o << "(0,0)"; + } + } + + + +//! Print a matrix to the specified stream +template +inline +void +arma_ostream::print(std::ostream& o, const Mat& m, const bool modify) + { + arma_extra_debug_sigprint(); + + const arma_ostream_state stream_state(o); + + const std::streamsize cell_width = modify ? arma_ostream::modify_stream(o, m.memptr(), m.n_elem) : o.width(); + + const uword m_n_rows = m.n_rows; + const uword m_n_cols = m.n_cols; + + if(m.is_empty() == false) + { + if(m_n_cols > 0) + { + if(cell_width > 0) + { + for(uword row=0; row < m_n_rows; ++row) + { + for(uword col=0; col < m_n_cols; ++col) + { + // the cell width appears to be reset after each element is printed, + // hence we need to restore it + o.width(cell_width); + arma_ostream::print_elem(o, m.at(row,col)); + } + + o << '\n'; + } + } + else + { + for(uword row=0; row < m_n_rows; ++row) + { + for(uword col=0; col < m_n_cols-1; ++col) + { + arma_ostream::print_elem(o, m.at(row,col)); + o << ' '; + } + + arma_ostream::print_elem(o, m.at(row, m_n_cols-1)); + o << '\n'; + } + } + } + } + else + { + o << "[matrix size: " << m_n_rows << 'x' << m_n_cols << "]\n"; + } + + o.flush(); + stream_state.restore(o); + } + + + +//! Print a cube to the specified stream +template +inline +void +arma_ostream::print(std::ostream& o, const Cube& x, const bool modify) + { + arma_extra_debug_sigprint(); + + const arma_ostream_state stream_state(o); + + const std::streamsize cell_width = modify ? arma_ostream::modify_stream(o, x.memptr(), x.n_elem) : o.width(); + + if(x.is_empty() == false) + { + for(uword slice=0; slice < x.n_slices; ++slice) + { + o << "[cube slice " << slice << ']' << '\n'; + o.width(cell_width); + arma_ostream::print(o, x.slice(slice), false); + o << '\n'; + } + } + else + { + o << "[cube size: " << x.n_rows << 'x' << x.n_cols << 'x' << x.n_slices << "]\n"; + } + + stream_state.restore(o); + } + + + + +//! Print a field to the specified stream +//! Assumes type oT can be printed, i.e. oT has std::ostream& operator<< (std::ostream&, const oT&) +template +inline +void +arma_ostream::print(std::ostream& o, const field& x) + { + arma_extra_debug_sigprint(); + + const arma_ostream_state stream_state(o); + + const std::streamsize cell_width = o.width(); + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if(x.is_empty() == false) + { + for(uword col=0; col +inline +void +arma_ostream::print(std::ostream& o, const subview_field& x) + { + arma_extra_debug_sigprint(); + + const arma_ostream_state stream_state(o); + + const std::streamsize cell_width = o.width(); + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + for(uword col=0; col +struct arma_type_check_cxx1998 + { + arma_inline + static + void + apply() + { + static const char + junk[ ERROR___INCORRECT_OR_UNSUPPORTED_TYPE ? -1 : +1 ]; + } + }; + + + +template<> +struct arma_type_check_cxx1998 + { + arma_inline + static + void + apply() + { + } + }; + + + +#if !defined(ARMA_USE_CXX11) + + #define arma_static_check(condition, message) static const char message[ (condition) ? -1 : +1 ] + + #define arma_type_check(condition) arma_type_check_cxx1998::apply() + +#else + + #define arma_static_check(condition, message) static_assert( !(condition), #message ) + + #define arma_type_check(condition) static_assert( !(condition), "error: incorrect or unsupported type" ) + +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arma_version.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arma_version.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,55 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arma_version +//! @{ + + + +#define ARMA_VERSION_MAJOR 2 +#define ARMA_VERSION_MINOR 4 +#define ARMA_VERSION_PATCH 4 +#define ARMA_VERSION_NAME "Loco Lounge Lizard" + + + +struct arma_version + { + static const unsigned int major = ARMA_VERSION_MAJOR; + static const unsigned int minor = ARMA_VERSION_MINOR; + static const unsigned int patch = ARMA_VERSION_PATCH; + + static + inline + std::string + as_string() + { + const char* nickname = ARMA_VERSION_NAME; + + std::stringstream ss; + ss << arma_version::major + << '.' + << arma_version::minor + << '.' + << arma_version::patch + << " (" + << nickname + << ')'; + + return ss.str(); + } + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arrayops_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arrayops_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,160 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arrayops +//! @{ + + +class arrayops + { + public: + + template + arma_hot arma_inline static void + copy(eT* dest, const eT* src, const uword n_elem); + + + template + static inline void + copy_big(eT* dest, const eT* src, const uword n_elem); + + + // + // array = convert(array) + + template + arma_hot arma_inline static void + convert_cx_scalar(out_eT& out, const in_eT& in, const typename arma_not_cx::result* junk1 = 0, const typename arma_not_cx< in_eT>::result* junk2 = 0); + + template + arma_hot arma_inline static void + convert_cx_scalar(out_eT& out, const std::complex& in, const typename arma_not_cx::result* junk = 0); + + template + arma_hot arma_inline static void + convert_cx_scalar(std::complex& out, const std::complex< in_T>& in); + + template + arma_hot inline static void + convert(out_eT* dest, const in_eT* src, const uword n_elem); + + template + arma_hot inline static void + convert_cx(out_eT* dest, const in_eT* src, const uword n_elem); + + + // + // array op= array + + template + arma_hot inline static + void + inplace_plus(eT* dest, const eT* src, const uword n_elem); + + template + arma_hot inline static + void + inplace_minus(eT* dest, const eT* src, const uword n_elem); + + template + arma_hot inline static + void + inplace_mul(eT* dest, const eT* src, const uword n_elem); + + template + arma_hot inline static + void + inplace_div(eT* dest, const eT* src, const uword n_elem); + + + // + // array op= scalar + + template + arma_hot inline static + void + inplace_set(eT* dest, const eT val, const uword n_elem); + + template + arma_hot inline static + void + inplace_plus(eT* dest, const eT val, const uword n_elem); + + template + arma_hot inline static + void + inplace_minus(eT* dest, const eT val, const uword n_elem); + + template + arma_hot inline static void + inplace_mul(eT* dest, const eT val, const uword n_elem); + + template + arma_hot inline static + void + inplace_div(eT* dest, const eT val, const uword n_elem); + + + // + // scalar = op(array) + + template + arma_hot arma_pure inline static + eT + accumulate(const eT* src, const uword n_elem); + + template + arma_hot arma_pure inline static + eT + product(const eT* src, const uword n_elem); + + template + arma_hot arma_pure inline static + bool + is_finite(const eT* src, const uword n_elem); + + template + arma_hot arma_pure inline static + typename get_pod_type::result + norm_1(const eT* src, const uword n_elem); + + template + arma_hot arma_pure inline static + eT + norm_2(const eT* src, const uword n_elem, const typename arma_not_cx::result* junk = 0); + + template + arma_hot arma_pure inline static + T + norm_2(const std::complex* src, const uword n_elem); + + template + arma_hot arma_pure inline static + typename get_pod_type::result + norm_k(const eT* src, const uword n_elem, const int k); + + template + arma_hot arma_pure inline static + typename get_pod_type::result + norm_max(const eT* src, const uword n_elem); + + template + arma_hot arma_pure inline static + typename get_pod_type::result + norm_min(const eT* src, const uword n_elem); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/arrayops_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/arrayops_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,714 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup arrayops +//! @{ + + + +template +arma_hot +arma_inline +void +arrayops::copy(eT* dest, const eT* src, const uword n_elem) + { + switch(n_elem) + { + default: + arrayops::copy_big(dest, src, n_elem); + break; + case 8: + dest[7] = src[7]; + case 7: + dest[6] = src[6]; + case 6: + dest[5] = src[5]; + case 5: + dest[4] = src[4]; + case 4: + dest[3] = src[3]; + case 3: + dest[2] = src[2]; + case 2: + dest[1] = src[1]; + case 1: + dest[0] = src[0]; + } + } + + + +template +inline +void +arrayops::copy_big(eT* dest, const eT* src, const uword n_elem) + { + switch(n_elem) + { + default: + std::memcpy(dest, src, n_elem*sizeof(eT)); + break; + case 32: + dest[31] = src[31]; + case 31: + dest[30] = src[30]; + case 30: + dest[29] = src[29]; + case 29: + dest[28] = src[28]; + case 28: + dest[27] = src[27]; + case 27: + dest[26] = src[26]; + case 26: + dest[25] = src[25]; + case 25: + dest[24] = src[24]; + case 24: + dest[23] = src[23]; + case 23: + dest[22] = src[22]; + case 22: + dest[21] = src[21]; + case 21: + dest[20] = src[20]; + case 20: + dest[19] = src[19]; + case 19: + dest[18] = src[18]; + case 18: + dest[17] = src[17]; + case 17: + dest[16] = src[16]; + case 16: + dest[15] = src[15]; + case 15: + dest[14] = src[14]; + case 14: + dest[13] = src[13]; + case 13: + dest[12] = src[12]; + case 12: + dest[11] = src[11]; + case 11: + dest[10] = src[10]; + case 10: + dest[9] = src[9]; + case 9: + dest[8] = src[8]; + case 8: + dest[7] = src[7]; + case 7: + dest[6] = src[6]; + case 6: + dest[5] = src[5]; + case 5: + dest[4] = src[4]; + case 4: + dest[3] = src[3]; + case 3: + dest[2] = src[2]; + case 2: + dest[1] = src[1]; + case 1: + dest[0] = src[0]; + } + } + + + +template +arma_hot +arma_inline +void +arrayops::convert_cx_scalar + ( + out_eT& out, + const in_eT& in, + const typename arma_not_cx::result* junk1, + const typename arma_not_cx< in_eT>::result* junk2 + ) + { + arma_ignore(junk1); + arma_ignore(junk2); + + out = out_eT(in); + } + + + +template +arma_hot +arma_inline +void +arrayops::convert_cx_scalar + ( + out_eT& out, + const std::complex& in, + const typename arma_not_cx::result* junk + ) + { + arma_ignore(junk); + + out = out_eT( in.real() ); + } + + + +template +arma_hot +arma_inline +void +arrayops::convert_cx_scalar + ( + std::complex& out, + const std::complex< in_T>& in + ) + { + typedef std::complex out_eT; + + out = out_eT(in); + } + + + +template +arma_hot +inline +void +arrayops::convert(out_eT* dest, const in_eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::convert_cx(out_eT* dest, const in_eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_plus(eT* dest, const eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_minus(eT* dest, const eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_mul(eT* dest, const eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_div(eT* dest, const eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_set(eT* dest, const eT val, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_plus(eT* dest, const eT val, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_minus(eT* dest, const eT val, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_mul(eT* dest, const eT val, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +void +arrayops::inplace_div(eT* dest, const eT val, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +eT +arrayops::accumulate(const eT* src, const uword n_elem) + { + uword i,j; + + eT acc1 = eT(0); + eT acc2 = eT(0); + + for(i=0, j=1; j +arma_hot +arma_pure +inline +eT +arrayops::product(const eT* src, const uword n_elem) + { + eT val1 = eT(1); + eT val2 = eT(1); + + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +bool +arrayops::is_finite(const eT* src, const uword n_elem) + { + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +typename get_pod_type::result +arrayops::norm_1(const eT* src, const uword n_elem) + { + typedef typename get_pod_type::result T; + + T acc = T(0); + + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +eT +arrayops::norm_2(const eT* src, const uword n_elem, const typename arma_not_cx::result* junk) + { + arma_ignore(junk); + + eT acc = eT(0); + + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +T +arrayops::norm_2(const std::complex* src, const uword n_elem) + { + T acc = T(0); + + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +typename get_pod_type::result +arrayops::norm_k(const eT* src, const uword n_elem, const int k) + { + typedef typename get_pod_type::result T; + + T acc = T(0); + + uword i,j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +typename get_pod_type::result +arrayops::norm_max(const eT* src, const uword n_elem) + { + typedef typename get_pod_type::result T; + + T max_val = std::abs(src[0]); + + uword i,j; + + for(i=1, j=2; j +arma_hot +arma_pure +inline +typename get_pod_type::result +arrayops::norm_min(const eT* src, const uword n_elem) + { + typedef typename get_pod_type::result T; + + T min_val = std::abs(src[0]); + + uword i,j; + + for(i=1, j=2; j tmp_i) { min_val = tmp_i; } + if(min_val > tmp_j) { min_val = tmp_j; } + } + + if(i < n_elem) + { + const T tmp_i = std::abs(src[i]); + + if(min_val > tmp_i) { min_val = tmp_i; } + } + + return min_val; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/atlas_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/atlas_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,89 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +#ifdef ARMA_USE_ATLAS + + +//! \namespace atlas namespace for ATLAS functions (imported from the global namespace) +namespace atlas + { + + using ::CblasColMajor; + using ::CblasNoTrans; + using ::CblasTrans; + using ::CblasConjTrans; + + #if defined(ARMA_USE_WRAPPER) + extern "C" + { + + float wrapper_cblas_sdot(const int N, const float *X, const int incX, const float *Y, const int incY); + double wrapper_cblas_ddot(const int N, const double *X, const int incX, const double *Y, const int incY); + + void wrapper_cblas_cdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); + void wrapper_cblas_zdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); + + + void wrapper_cblas_sgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const float alpha, + const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY); + + void wrapper_cblas_dgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const double alpha, + const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY); + + void wrapper_cblas_cgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, + const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); + + void wrapper_cblas_zgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, + const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); + + + + void wrapper_cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const float alpha, + const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc); + + void wrapper_cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const double alpha, + const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc); + + void wrapper_cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const void *alpha, + const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); + + void wrapper_cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const void *alpha, + const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); + + + int wrapper_clapack_sgetrf(const enum CBLAS_ORDER Order, const int M, const int N, float *A, const int lda, int *ipiv); + int wrapper_clapack_dgetrf(const enum CBLAS_ORDER Order, const int M, const int N, double *A, const int lda, int *ipiv); + int wrapper_clapack_cgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv); + int wrapper_clapack_zgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv); + + int wrapper_clapack_sgetri(const enum CBLAS_ORDER Order, const int N, float *A, const int lda, const int *ipiv); + int wrapper_clapack_dgetri(const enum CBLAS_ORDER Order, const int N, double *A, const int lda, const int *ipiv); + int wrapper_clapack_cgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv); + int wrapper_clapack_zgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv); + + int wrapper_clapack_sgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, float *A, const int lda, int *ipiv, float *B, const int ldb); + int wrapper_clapack_dgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, double *A, const int lda, int *ipiv, double *B, const int ldb); + int wrapper_clapack_cgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb); + int wrapper_clapack_zgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb); + + } + #endif + + } + + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/atlas_wrapper.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/atlas_wrapper.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,303 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +#ifdef ARMA_USE_ATLAS + + +//! \namespace atlas namespace for ATLAS functions (imported from the global namespace) +namespace atlas + { + + template + inline static const eT& tmp_real(const eT& X) { return X; } + + template + inline static const T& tmp_real(const std::complex& X) { return X.real(); } + + + + template + arma_inline + eT + cblas_dot(const int N, const eT* X, const eT* Y) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + return eT( arma_atlas(cblas_sdot)(N, (const T*)X, 1, (const T*)Y, 1) ); + } + else + if(is_double::value == true) + { + typedef double T; + return eT( arma_atlas(cblas_ddot)(N, (const T*)X, 1, (const T*)Y, 1) ); + } + else + { + return eT(0); + } + } + + + + template + arma_inline + eT + cx_cblas_dot(const int N, const eT* X, const eT* Y) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_supported_complex_float::value == true) + { + typedef typename std::complex T; + + T out; + arma_atlas(cblas_cdotu_sub)(N, (const T*)X, 1, (const T*)Y, 1, &out); + + return eT(out); + } + else + if(is_supported_complex_double::value == true) + { + typedef typename std::complex T; + + T out; + arma_atlas(cblas_zdotu_sub)(N, (const T*)X, 1, (const T*)Y, 1, &out); + + return eT(out); + } + else + { + return eT(0); + } + } + + + + template + inline + void + cblas_gemv + ( + const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, + const int M, const int N, + const eT alpha, + const eT *A, const int lda, + const eT *X, const int incX, + const eT beta, + eT *Y, const int incY + ) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + arma_atlas(cblas_sgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); + } + else + if(is_double::value == true) + { + typedef double T; + arma_atlas(cblas_dgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_atlas(cblas_cgemv)(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_atlas(cblas_zgemv)(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); + } + } + + + + template + inline + void + cblas_gemm + ( + const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, + const enum CBLAS_TRANSPOSE TransB, const int M, const int N, + const int K, const eT alpha, const eT *A, + const int lda, const eT *B, const int ldb, + const eT beta, eT *C, const int ldc + ) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + arma_atlas(cblas_sgemm)(Order, TransA, TransB, M, N, K, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ldc); + } + else + if(is_double::value == true) + { + typedef double T; + arma_atlas(cblas_dgemm)(Order, TransA, TransB, M, N, K, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ldc); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_atlas(cblas_cgemm)(Order, TransA, TransB, M, N, K, (const T*)&alpha, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_atlas(cblas_zgemm)(Order, TransA, TransB, M, N, K, (const T*)&alpha, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc); + } + } + + + + template + inline + int + clapack_getrf + ( + const enum CBLAS_ORDER Order, const int M, const int N, + eT *A, const int lda, int *ipiv + ) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + return arma_atlas(clapack_sgetrf)(Order, M, N, (T*)A, lda, ipiv); + } + else + if(is_double::value == true) + { + typedef double T; + return arma_atlas(clapack_dgetrf)(Order, M, N, (T*)A, lda, ipiv); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_cgetrf)(Order, M, N, (T*)A, lda, ipiv); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_zgetrf)(Order, M, N, (T*)A, lda, ipiv); + } + else + { + return -1; + } + } + + + + template + inline + int + clapack_getri + ( + const enum CBLAS_ORDER Order, const int N, eT *A, + const int lda, const int *ipiv + ) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + return arma_atlas(clapack_sgetri)(Order, N, (T*)A, lda, ipiv); + } + else + if(is_double::value == true) + { + typedef double T; + return arma_atlas(clapack_dgetri)(Order, N, (T*)A, lda, ipiv); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_cgetri)(Order, N, (T*)A, lda, ipiv); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_zgetri)(Order, N, (T*)A, lda, ipiv); + } + else + { + return -1; + } + } + + + + template + inline + int + clapack_gesv + ( + const enum CBLAS_ORDER Order, + const int N, const int NRHS, + eT* A, const int lda, int* ipiv, + eT* B, const int ldb + ) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + return arma_atlas(clapack_sgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B, ldb); + } + else + if(is_double::value == true) + { + typedef double T; + return arma_atlas(clapack_dgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B, ldb); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_cgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B, ldb); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + return arma_atlas(clapack_zgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B, ldb); + } + else + { + return -1; + } + } + + + + } + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/auxlib_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/auxlib_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,224 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009 Edmund Highcock +// Copyright (C) 2011 James Sanders +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup auxlib +//! @{ + + +//! wrapper for accessing external functions defined in ATLAS, LAPACK or BLAS libraries +class auxlib + { + public: + + + template + struct pos + { + static const uword n2 = row + col*2; + static const uword n3 = row + col*3; + static const uword n4 = row + col*4; + }; + + + // + // inv + + template + inline static bool inv(Mat& out, const Base& X, const bool slow = false); + + template + inline static bool inv(Mat& out, const Mat& A, const bool slow = false); + + template + inline static bool inv_noalias_tinymat(Mat& out, const Mat& X, const uword N); + + template + inline static bool inv_inplace_tinymat(Mat& out, const uword N); + + template + inline static bool inv_inplace_lapack(Mat& out); + + + // + // inv_tr + + template + inline static bool inv_tr(Mat& out, const Base& X, const uword layout); + + + // + // inv_sym + + template + inline static bool inv_sym(Mat& out, const Base& X, const uword layout); + + + // + // inv_sympd + + template + inline static bool inv_sympd(Mat& out, const Base& X, const uword layout); + + + // + // det + + template + inline static eT det(const Base& X, const bool slow = false); + + template + inline static eT det_tinymat(const Mat& X, const uword N); + + template + inline static eT det_lapack(const Mat& X, const bool make_copy); + + + // + // log_det + + template + inline static bool log_det(eT& out_val, typename get_pod_type::result& out_sign, const Base& X); + + + // + // lu + + template + inline static bool lu(Mat& L, Mat& U, podarray& ipiv, const Base& X); + + template + inline static bool lu(Mat& L, Mat& U, Mat& P, const Base& X); + + template + inline static bool lu(Mat& L, Mat& U, const Base& X); + + + // + // eig + + template + inline static bool eig_sym(Col& eigval, const Base& X); + + template + inline static bool eig_sym(Col& eigval, const Base,T1>& X); + + template + inline static bool eig_sym(Col& eigval, Mat& eigvec, const Base& X); + + template + inline static bool eig_sym(Col& eigval, Mat< std::complex >& eigvec, const Base,T1>& X); + + template + inline static bool eig_gen(Col< std::complex >& eigval, Mat& l_eigvec, Mat& r_eigvec, const Base& X, const char side); + + template + inline static bool eig_gen(Col< std::complex >& eigval, Mat< std::complex >& l_eigvec, Mat< std::complex >& r_eigvec, const Base< std::complex, T1 >& X, const char side); + + + // + // chol + + template + inline static bool chol(Mat& out, const Base& X); + + + // + // qr + + template + inline static bool qr(Mat& Q, Mat& R, const Base& X); + + + // + // svd + + template + inline static bool svd(Col& S, const Base& X, uword& n_rows, uword& n_cols); + + template + inline static bool svd(Col& S, const Base, T1>& X, uword& n_rows, uword& n_cols); + + template + inline static bool svd(Col& S, const Base& X); + + template + inline static bool svd(Col& S, const Base, T1>& X); + + template + inline static bool svd(Mat& U, Col& S, Mat& V, const Base& X); + + template + inline static bool svd(Mat< std::complex >& U, Col& S, Mat< std::complex >& V, const Base< std::complex, T1>& X); + + template + inline static bool svd_econ(Mat& U, Col& S, Mat& V, const Base& X, const char mode); + + template + inline static bool svd_econ(Mat< std::complex >& U, Col& S, Mat< std::complex >& V, const Base< std::complex, T1>& X, const char mode); + + + // + // solve + + template + inline static bool solve (Mat& out, Mat& A, const Mat& B, const bool slow = false); + + template + inline static bool solve_od(Mat& out, Mat& A, const Mat& B); + + template + inline static bool solve_ud(Mat& out, Mat& A, const Mat& B); + + + // + // solve_tr + + template + inline static bool solve_tr(Mat& out, const Mat& A, const Mat& B, const uword layout); + + + // + // Schur decomposition + + template + inline static bool schur_dec(Mat& Z, Mat& T, const Mat& A); + + template + inline static bool schur_dec(Mat >& Z, Mat >& T, const Mat >& A); + + + // + // syl (solution of the Sylvester equation AX + XB = C) + + template + inline static bool syl(Mat& X, const Mat& A, const Mat& B, const Mat& C); + + + // + // lyap (solution of the continuous Lyapunov equation AX + XA^H + Q = 0) + + template + inline static bool lyap(Mat& X, const Mat& A, const Mat& Q); + + + // + // dlyap (solution of the discrete Lyapunov equation AXA^H - X + Q = 0) + + template + inline static bool dlyap(Mat& X, const Mat& A, const Mat& Q); + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/auxlib_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/auxlib_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,2926 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// Copyright (C) 2009 Edmund Highcock +// Copyright (C) 2011 James Sanders +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup auxlib +//! @{ + + + +//! immediate matrix inverse +template +inline +bool +auxlib::inv(Mat& out, const Base& X, const bool slow) + { + arma_extra_debug_sigprint(); + + out = X.get_ref(); + + arma_debug_check( (out.is_square() == false), "inv(): given matrix is not square" ); + + bool status = false; + + const uword N = out.n_rows; + + if( (N <= 4) && (slow == false) ) + { + status = auxlib::inv_inplace_tinymat(out, N); + } + + if( (N > 4) || (status == false) ) + { + status = auxlib::inv_inplace_lapack(out); + } + + return status; + } + + + +template +inline +bool +auxlib::inv(Mat& out, const Mat& X, const bool slow) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (X.is_square() == false), "inv(): given matrix is not square" ); + + bool status = false; + + const uword N = X.n_rows; + + if( (N <= 4) && (slow == false) ) + { + status = (&out != &X) ? auxlib::inv_noalias_tinymat(out, X, N) : auxlib::inv_inplace_tinymat(out, N); + } + + if( (N > 4) || (status == false) ) + { + out = X; + status = auxlib::inv_inplace_lapack(out); + } + + return status; + } + + + +template +inline +bool +auxlib::inv_noalias_tinymat(Mat& out, const Mat& X, const uword N) + { + arma_extra_debug_sigprint(); + + bool det_ok = true; + + out.set_size(N,N); + + switch(N) + { + case 1: + { + out[0] = eT(1) / X[0]; + }; + break; + + case 2: + { + const eT* Xm = X.memptr(); + + const eT a = Xm[pos<0,0>::n2]; + const eT b = Xm[pos<0,1>::n2]; + const eT c = Xm[pos<1,0>::n2]; + const eT d = Xm[pos<1,1>::n2]; + + const eT tmp_det = (a*d - b*c); + + if(tmp_det != eT(0)) + { + eT* outm = out.memptr(); + + outm[pos<0,0>::n2] = d / tmp_det; + outm[pos<0,1>::n2] = -b / tmp_det; + outm[pos<1,0>::n2] = -c / tmp_det; + outm[pos<1,1>::n2] = a / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + case 3: + { + const eT* X_col0 = X.colptr(0); + const eT a11 = X_col0[0]; + const eT a21 = X_col0[1]; + const eT a31 = X_col0[2]; + + const eT* X_col1 = X.colptr(1); + const eT a12 = X_col1[0]; + const eT a22 = X_col1[1]; + const eT a32 = X_col1[2]; + + const eT* X_col2 = X.colptr(2); + const eT a13 = X_col2[0]; + const eT a23 = X_col2[1]; + const eT a33 = X_col2[2]; + + const eT tmp_det = a11*(a33*a22 - a32*a23) - a21*(a33*a12-a32*a13) + a31*(a23*a12 - a22*a13); + + if(tmp_det != eT(0)) + { + eT* out_col0 = out.colptr(0); + out_col0[0] = (a33*a22 - a32*a23) / tmp_det; + out_col0[1] = -(a33*a21 - a31*a23) / tmp_det; + out_col0[2] = (a32*a21 - a31*a22) / tmp_det; + + eT* out_col1 = out.colptr(1); + out_col1[0] = -(a33*a12 - a32*a13) / tmp_det; + out_col1[1] = (a33*a11 - a31*a13) / tmp_det; + out_col1[2] = -(a32*a11 - a31*a12) / tmp_det; + + eT* out_col2 = out.colptr(2); + out_col2[0] = (a23*a12 - a22*a13) / tmp_det; + out_col2[1] = -(a23*a11 - a21*a13) / tmp_det; + out_col2[2] = (a22*a11 - a21*a12) / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + case 4: + { + const eT tmp_det = det(X); + + if(tmp_det != eT(0)) + { + const eT* Xm = X.memptr(); + eT* outm = out.memptr(); + + outm[pos<0,0>::n4] = ( Xm[pos<1,2>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,1>::n4] - Xm[pos<1,3>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,1>::n4] + Xm[pos<1,3>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,2>::n4] - Xm[pos<1,1>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,2>::n4] - Xm[pos<1,2>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,3>::n4] + Xm[pos<1,1>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<1,0>::n4] = ( Xm[pos<1,3>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,0>::n4] - Xm[pos<1,2>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<1,3>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,2>::n4] + Xm[pos<1,0>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,2>::n4] + Xm[pos<1,2>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,3>::n4] - Xm[pos<1,0>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<2,0>::n4] = ( Xm[pos<1,1>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<1,3>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,0>::n4] + Xm[pos<1,3>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,1>::n4] - Xm[pos<1,0>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,1>::n4] - Xm[pos<1,1>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,3>::n4] + Xm[pos<1,0>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<3,0>::n4] = ( Xm[pos<1,2>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,0>::n4] - Xm[pos<1,1>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,0>::n4] - Xm[pos<1,2>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,1>::n4] + Xm[pos<1,0>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,1>::n4] + Xm[pos<1,1>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,2>::n4] - Xm[pos<1,0>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,2>::n4] ) / tmp_det; + + outm[pos<0,1>::n4] = ( Xm[pos<0,3>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,2>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,3>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,2>::n4] + Xm[pos<0,1>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,2>::n4] + Xm[pos<0,2>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,3>::n4] - Xm[pos<0,1>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<1,1>::n4] = ( Xm[pos<0,2>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,0>::n4] + Xm[pos<0,3>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,2>::n4] - Xm[pos<0,0>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,2>::n4] - Xm[pos<0,2>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,3>::n4] + Xm[pos<0,0>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<2,1>::n4] = ( Xm[pos<0,3>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,1>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,1>::n4] + Xm[pos<0,0>::n4]*Xm[pos<2,3>::n4]*Xm[pos<3,1>::n4] + Xm[pos<0,1>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,3>::n4] - Xm[pos<0,0>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<3,1>::n4] = ( Xm[pos<0,1>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,2>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,0>::n4] + Xm[pos<0,2>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,0>::n4]*Xm[pos<2,2>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,1>::n4]*Xm[pos<2,0>::n4]*Xm[pos<3,2>::n4] + Xm[pos<0,0>::n4]*Xm[pos<2,1>::n4]*Xm[pos<3,2>::n4] ) / tmp_det; + + outm[pos<0,2>::n4] = ( Xm[pos<0,2>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,1>::n4] + Xm[pos<0,3>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,2>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,2>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,3>::n4] + Xm[pos<0,1>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<1,2>::n4] = ( Xm[pos<0,3>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,2>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,2>::n4] + Xm[pos<0,2>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,3>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<2,2>::n4] = ( Xm[pos<0,1>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,0>::n4] + Xm[pos<0,3>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,3>::n4]*Xm[pos<3,1>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,3>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,3>::n4] ) / tmp_det; + outm[pos<3,2>::n4] = ( Xm[pos<0,2>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,0>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,1>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,2>::n4]*Xm[pos<3,1>::n4] + Xm[pos<0,1>::n4]*Xm[pos<1,0>::n4]*Xm[pos<3,2>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,1>::n4]*Xm[pos<3,2>::n4] ) / tmp_det; + + outm[pos<0,3>::n4] = ( Xm[pos<0,3>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,1>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,1>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,2>::n4] + Xm[pos<0,1>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,2>::n4] + Xm[pos<0,2>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,3>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,3>::n4] ) / tmp_det; + outm[pos<1,3>::n4] = ( Xm[pos<0,2>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,0>::n4] + Xm[pos<0,3>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,2>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,2>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,3>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,3>::n4] ) / tmp_det; + outm[pos<2,3>::n4] = ( Xm[pos<0,3>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,0>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,0>::n4] - Xm[pos<0,3>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,1>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,3>::n4]*Xm[pos<2,1>::n4] + Xm[pos<0,1>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,3>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,3>::n4] ) / tmp_det; + outm[pos<3,3>::n4] = ( Xm[pos<0,1>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,0>::n4] - Xm[pos<0,2>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,0>::n4] + Xm[pos<0,2>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,1>::n4] - Xm[pos<0,0>::n4]*Xm[pos<1,2>::n4]*Xm[pos<2,1>::n4] - Xm[pos<0,1>::n4]*Xm[pos<1,0>::n4]*Xm[pos<2,2>::n4] + Xm[pos<0,0>::n4]*Xm[pos<1,1>::n4]*Xm[pos<2,2>::n4] ) / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + default: + ; + } + + return det_ok; + } + + + +template +inline +bool +auxlib::inv_inplace_tinymat(Mat& X, const uword N) + { + arma_extra_debug_sigprint(); + + bool det_ok = true; + + // for more info, see: + // http://www.dr-lex.34sp.com/random/matrix_inv.html + // http://www.cvl.iis.u-tokyo.ac.jp/~miyazaki/tech/teche23.html + // http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm + // http://www.geometrictools.com//LibFoundation/Mathematics/Wm4Matrix4.inl + + switch(N) + { + case 1: + { + X[0] = eT(1) / X[0]; + }; + break; + + case 2: + { + const eT a = X[pos<0,0>::n2]; + const eT b = X[pos<0,1>::n2]; + const eT c = X[pos<1,0>::n2]; + const eT d = X[pos<1,1>::n2]; + + const eT tmp_det = (a*d - b*c); + + if(tmp_det != eT(0)) + { + X[pos<0,0>::n2] = d / tmp_det; + X[pos<0,1>::n2] = -b / tmp_det; + X[pos<1,0>::n2] = -c / tmp_det; + X[pos<1,1>::n2] = a / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + case 3: + { + eT* X_col0 = X.colptr(0); + eT* X_col1 = X.colptr(1); + eT* X_col2 = X.colptr(2); + + const eT a11 = X_col0[0]; + const eT a21 = X_col0[1]; + const eT a31 = X_col0[2]; + + const eT a12 = X_col1[0]; + const eT a22 = X_col1[1]; + const eT a32 = X_col1[2]; + + const eT a13 = X_col2[0]; + const eT a23 = X_col2[1]; + const eT a33 = X_col2[2]; + + const eT tmp_det = a11*(a33*a22 - a32*a23) - a21*(a33*a12-a32*a13) + a31*(a23*a12 - a22*a13); + + if(tmp_det != eT(0)) + { + X_col0[0] = (a33*a22 - a32*a23) / tmp_det; + X_col0[1] = -(a33*a21 - a31*a23) / tmp_det; + X_col0[2] = (a32*a21 - a31*a22) / tmp_det; + + X_col1[0] = -(a33*a12 - a32*a13) / tmp_det; + X_col1[1] = (a33*a11 - a31*a13) / tmp_det; + X_col1[2] = -(a32*a11 - a31*a12) / tmp_det; + + X_col2[0] = (a23*a12 - a22*a13) / tmp_det; + X_col2[1] = -(a23*a11 - a21*a13) / tmp_det; + X_col2[2] = (a22*a11 - a21*a12) / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + case 4: + { + const eT tmp_det = det(X); + + if(tmp_det != eT(0)) + { + const Mat A(X); + + const eT* Am = A.memptr(); + eT* Xm = X.memptr(); + + Xm[pos<0,0>::n4] = ( Am[pos<1,2>::n4]*Am[pos<2,3>::n4]*Am[pos<3,1>::n4] - Am[pos<1,3>::n4]*Am[pos<2,2>::n4]*Am[pos<3,1>::n4] + Am[pos<1,3>::n4]*Am[pos<2,1>::n4]*Am[pos<3,2>::n4] - Am[pos<1,1>::n4]*Am[pos<2,3>::n4]*Am[pos<3,2>::n4] - Am[pos<1,2>::n4]*Am[pos<2,1>::n4]*Am[pos<3,3>::n4] + Am[pos<1,1>::n4]*Am[pos<2,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<1,0>::n4] = ( Am[pos<1,3>::n4]*Am[pos<2,2>::n4]*Am[pos<3,0>::n4] - Am[pos<1,2>::n4]*Am[pos<2,3>::n4]*Am[pos<3,0>::n4] - Am[pos<1,3>::n4]*Am[pos<2,0>::n4]*Am[pos<3,2>::n4] + Am[pos<1,0>::n4]*Am[pos<2,3>::n4]*Am[pos<3,2>::n4] + Am[pos<1,2>::n4]*Am[pos<2,0>::n4]*Am[pos<3,3>::n4] - Am[pos<1,0>::n4]*Am[pos<2,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<2,0>::n4] = ( Am[pos<1,1>::n4]*Am[pos<2,3>::n4]*Am[pos<3,0>::n4] - Am[pos<1,3>::n4]*Am[pos<2,1>::n4]*Am[pos<3,0>::n4] + Am[pos<1,3>::n4]*Am[pos<2,0>::n4]*Am[pos<3,1>::n4] - Am[pos<1,0>::n4]*Am[pos<2,3>::n4]*Am[pos<3,1>::n4] - Am[pos<1,1>::n4]*Am[pos<2,0>::n4]*Am[pos<3,3>::n4] + Am[pos<1,0>::n4]*Am[pos<2,1>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<3,0>::n4] = ( Am[pos<1,2>::n4]*Am[pos<2,1>::n4]*Am[pos<3,0>::n4] - Am[pos<1,1>::n4]*Am[pos<2,2>::n4]*Am[pos<3,0>::n4] - Am[pos<1,2>::n4]*Am[pos<2,0>::n4]*Am[pos<3,1>::n4] + Am[pos<1,0>::n4]*Am[pos<2,2>::n4]*Am[pos<3,1>::n4] + Am[pos<1,1>::n4]*Am[pos<2,0>::n4]*Am[pos<3,2>::n4] - Am[pos<1,0>::n4]*Am[pos<2,1>::n4]*Am[pos<3,2>::n4] ) / tmp_det; + + Xm[pos<0,1>::n4] = ( Am[pos<0,3>::n4]*Am[pos<2,2>::n4]*Am[pos<3,1>::n4] - Am[pos<0,2>::n4]*Am[pos<2,3>::n4]*Am[pos<3,1>::n4] - Am[pos<0,3>::n4]*Am[pos<2,1>::n4]*Am[pos<3,2>::n4] + Am[pos<0,1>::n4]*Am[pos<2,3>::n4]*Am[pos<3,2>::n4] + Am[pos<0,2>::n4]*Am[pos<2,1>::n4]*Am[pos<3,3>::n4] - Am[pos<0,1>::n4]*Am[pos<2,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<1,1>::n4] = ( Am[pos<0,2>::n4]*Am[pos<2,3>::n4]*Am[pos<3,0>::n4] - Am[pos<0,3>::n4]*Am[pos<2,2>::n4]*Am[pos<3,0>::n4] + Am[pos<0,3>::n4]*Am[pos<2,0>::n4]*Am[pos<3,2>::n4] - Am[pos<0,0>::n4]*Am[pos<2,3>::n4]*Am[pos<3,2>::n4] - Am[pos<0,2>::n4]*Am[pos<2,0>::n4]*Am[pos<3,3>::n4] + Am[pos<0,0>::n4]*Am[pos<2,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<2,1>::n4] = ( Am[pos<0,3>::n4]*Am[pos<2,1>::n4]*Am[pos<3,0>::n4] - Am[pos<0,1>::n4]*Am[pos<2,3>::n4]*Am[pos<3,0>::n4] - Am[pos<0,3>::n4]*Am[pos<2,0>::n4]*Am[pos<3,1>::n4] + Am[pos<0,0>::n4]*Am[pos<2,3>::n4]*Am[pos<3,1>::n4] + Am[pos<0,1>::n4]*Am[pos<2,0>::n4]*Am[pos<3,3>::n4] - Am[pos<0,0>::n4]*Am[pos<2,1>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<3,1>::n4] = ( Am[pos<0,1>::n4]*Am[pos<2,2>::n4]*Am[pos<3,0>::n4] - Am[pos<0,2>::n4]*Am[pos<2,1>::n4]*Am[pos<3,0>::n4] + Am[pos<0,2>::n4]*Am[pos<2,0>::n4]*Am[pos<3,1>::n4] - Am[pos<0,0>::n4]*Am[pos<2,2>::n4]*Am[pos<3,1>::n4] - Am[pos<0,1>::n4]*Am[pos<2,0>::n4]*Am[pos<3,2>::n4] + Am[pos<0,0>::n4]*Am[pos<2,1>::n4]*Am[pos<3,2>::n4] ) / tmp_det; + + Xm[pos<0,2>::n4] = ( Am[pos<0,2>::n4]*Am[pos<1,3>::n4]*Am[pos<3,1>::n4] - Am[pos<0,3>::n4]*Am[pos<1,2>::n4]*Am[pos<3,1>::n4] + Am[pos<0,3>::n4]*Am[pos<1,1>::n4]*Am[pos<3,2>::n4] - Am[pos<0,1>::n4]*Am[pos<1,3>::n4]*Am[pos<3,2>::n4] - Am[pos<0,2>::n4]*Am[pos<1,1>::n4]*Am[pos<3,3>::n4] + Am[pos<0,1>::n4]*Am[pos<1,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<1,2>::n4] = ( Am[pos<0,3>::n4]*Am[pos<1,2>::n4]*Am[pos<3,0>::n4] - Am[pos<0,2>::n4]*Am[pos<1,3>::n4]*Am[pos<3,0>::n4] - Am[pos<0,3>::n4]*Am[pos<1,0>::n4]*Am[pos<3,2>::n4] + Am[pos<0,0>::n4]*Am[pos<1,3>::n4]*Am[pos<3,2>::n4] + Am[pos<0,2>::n4]*Am[pos<1,0>::n4]*Am[pos<3,3>::n4] - Am[pos<0,0>::n4]*Am[pos<1,2>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<2,2>::n4] = ( Am[pos<0,1>::n4]*Am[pos<1,3>::n4]*Am[pos<3,0>::n4] - Am[pos<0,3>::n4]*Am[pos<1,1>::n4]*Am[pos<3,0>::n4] + Am[pos<0,3>::n4]*Am[pos<1,0>::n4]*Am[pos<3,1>::n4] - Am[pos<0,0>::n4]*Am[pos<1,3>::n4]*Am[pos<3,1>::n4] - Am[pos<0,1>::n4]*Am[pos<1,0>::n4]*Am[pos<3,3>::n4] + Am[pos<0,0>::n4]*Am[pos<1,1>::n4]*Am[pos<3,3>::n4] ) / tmp_det; + Xm[pos<3,2>::n4] = ( Am[pos<0,2>::n4]*Am[pos<1,1>::n4]*Am[pos<3,0>::n4] - Am[pos<0,1>::n4]*Am[pos<1,2>::n4]*Am[pos<3,0>::n4] - Am[pos<0,2>::n4]*Am[pos<1,0>::n4]*Am[pos<3,1>::n4] + Am[pos<0,0>::n4]*Am[pos<1,2>::n4]*Am[pos<3,1>::n4] + Am[pos<0,1>::n4]*Am[pos<1,0>::n4]*Am[pos<3,2>::n4] - Am[pos<0,0>::n4]*Am[pos<1,1>::n4]*Am[pos<3,2>::n4] ) / tmp_det; + + Xm[pos<0,3>::n4] = ( Am[pos<0,3>::n4]*Am[pos<1,2>::n4]*Am[pos<2,1>::n4] - Am[pos<0,2>::n4]*Am[pos<1,3>::n4]*Am[pos<2,1>::n4] - Am[pos<0,3>::n4]*Am[pos<1,1>::n4]*Am[pos<2,2>::n4] + Am[pos<0,1>::n4]*Am[pos<1,3>::n4]*Am[pos<2,2>::n4] + Am[pos<0,2>::n4]*Am[pos<1,1>::n4]*Am[pos<2,3>::n4] - Am[pos<0,1>::n4]*Am[pos<1,2>::n4]*Am[pos<2,3>::n4] ) / tmp_det; + Xm[pos<1,3>::n4] = ( Am[pos<0,2>::n4]*Am[pos<1,3>::n4]*Am[pos<2,0>::n4] - Am[pos<0,3>::n4]*Am[pos<1,2>::n4]*Am[pos<2,0>::n4] + Am[pos<0,3>::n4]*Am[pos<1,0>::n4]*Am[pos<2,2>::n4] - Am[pos<0,0>::n4]*Am[pos<1,3>::n4]*Am[pos<2,2>::n4] - Am[pos<0,2>::n4]*Am[pos<1,0>::n4]*Am[pos<2,3>::n4] + Am[pos<0,0>::n4]*Am[pos<1,2>::n4]*Am[pos<2,3>::n4] ) / tmp_det; + Xm[pos<2,3>::n4] = ( Am[pos<0,3>::n4]*Am[pos<1,1>::n4]*Am[pos<2,0>::n4] - Am[pos<0,1>::n4]*Am[pos<1,3>::n4]*Am[pos<2,0>::n4] - Am[pos<0,3>::n4]*Am[pos<1,0>::n4]*Am[pos<2,1>::n4] + Am[pos<0,0>::n4]*Am[pos<1,3>::n4]*Am[pos<2,1>::n4] + Am[pos<0,1>::n4]*Am[pos<1,0>::n4]*Am[pos<2,3>::n4] - Am[pos<0,0>::n4]*Am[pos<1,1>::n4]*Am[pos<2,3>::n4] ) / tmp_det; + Xm[pos<3,3>::n4] = ( Am[pos<0,1>::n4]*Am[pos<1,2>::n4]*Am[pos<2,0>::n4] - Am[pos<0,2>::n4]*Am[pos<1,1>::n4]*Am[pos<2,0>::n4] + Am[pos<0,2>::n4]*Am[pos<1,0>::n4]*Am[pos<2,1>::n4] - Am[pos<0,0>::n4]*Am[pos<1,2>::n4]*Am[pos<2,1>::n4] - Am[pos<0,1>::n4]*Am[pos<1,0>::n4]*Am[pos<2,2>::n4] + Am[pos<0,0>::n4]*Am[pos<1,1>::n4]*Am[pos<2,2>::n4] ) / tmp_det; + } + else + { + det_ok = false; + } + }; + break; + + default: + ; + } + + return det_ok; + } + + + +template +inline +bool +auxlib::inv_inplace_lapack(Mat& out) + { + arma_extra_debug_sigprint(); + + if(out.is_empty()) + { + return true; + } + + #if defined(ARMA_USE_ATLAS) + { + podarray ipiv(out.n_rows); + + int info = atlas::clapack_getrf(atlas::CblasColMajor, out.n_rows, out.n_cols, out.memptr(), out.n_rows, ipiv.memptr()); + + if(info == 0) + { + info = atlas::clapack_getri(atlas::CblasColMajor, out.n_rows, out.memptr(), out.n_rows, ipiv.memptr()); + } + + return (info == 0); + } + #elif defined(ARMA_USE_LAPACK) + { + blas_int n_rows = out.n_rows; + blas_int n_cols = out.n_cols; + blas_int info = 0; + + podarray ipiv(out.n_rows); + + // 84 was empirically found -- it is the maximum value suggested by LAPACK (as provided by ATLAS v3.6) + // based on tests with various matrix types on 32-bit and 64-bit machines + // + // the "work" array is deliberately long so that a secondary (time-consuming) + // memory allocation is avoided, if possible + + blas_int work_len = (std::max)(blas_int(1), n_rows*84); + podarray work( static_cast(work_len) ); + + lapack::getrf(&n_rows, &n_cols, out.memptr(), &n_rows, ipiv.memptr(), &info); + + if(info == 0) + { + // query for optimum size of work_len + + blas_int work_len_tmp = -1; + lapack::getri(&n_rows, out.memptr(), &n_rows, ipiv.memptr(), work.memptr(), &work_len_tmp, &info); + + if(info == 0) + { + blas_int proposed_work_len = static_cast(access::tmp_real(work[0])); + + // if necessary, allocate more memory + if(work_len < proposed_work_len) + { + work_len = proposed_work_len; + work.set_size( static_cast(work_len) ); + } + } + + lapack::getri(&n_rows, out.memptr(), &n_rows, ipiv.memptr(), work.memptr(), &work_len, &info); + } + + return (info == 0); + } + #else + { + arma_ignore(out); + arma_stop("inv(): use of ATLAS or LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::inv_tr(Mat& out, const Base& X, const uword layout) + { + arma_extra_debug_sigprint(); + + out = X.get_ref(); + + arma_debug_check( (out.is_square() == false), "inv(): given matrix is not square" ); + + if(out.is_empty()) + { + return true; + } + + bool status; + + #if defined(ARMA_USE_LAPACK) + { + char uplo = (layout == 0) ? 'U' : 'L'; + char diag = 'N'; + blas_int n = blas_int(out.n_rows); + blas_int info = 0; + + lapack::trtri(&uplo, &diag, &n, out.memptr(), &n, &info); + + status = (info == 0); + } + #else + { + arma_ignore(layout); + arma_stop("inv(): use of LAPACK needs to be enabled"); + status = false; + } + #endif + + + if(status == true) + { + if(layout == 0) + { + // upper triangular + out = trimatu(out); + } + else + { + // lower triangular + out = trimatl(out); + } + } + + return status; + } + + + +template +inline +bool +auxlib::inv_sym(Mat& out, const Base& X, const uword layout) + { + arma_extra_debug_sigprint(); + + out = X.get_ref(); + + arma_debug_check( (out.is_square() == false), "inv(): given matrix is not square" ); + + if(out.is_empty()) + { + return true; + } + + bool status; + + #if defined(ARMA_USE_LAPACK) + { + char uplo = (layout == 0) ? 'U' : 'L'; + blas_int n = blas_int(out.n_rows); + blas_int lwork = n*n; // TODO: use lwork = -1 to determine optimal size + blas_int info = 0; + + podarray ipiv; + ipiv.set_size(out.n_rows); + + podarray work; + work.set_size( uword(lwork) ); + + lapack::sytrf(&uplo, &n, out.memptr(), &n, ipiv.memptr(), work.memptr(), &lwork, &info); + + status = (info == 0); + + if(status == true) + { + lapack::sytri(&uplo, &n, out.memptr(), &n, ipiv.memptr(), work.memptr(), &info); + + out = (layout == 0) ? symmatu(out) : symmatl(out); + + status = (info == 0); + } + } + #else + { + arma_ignore(layout); + arma_stop("inv(): use of LAPACK needs to be enabled"); + status = false; + } + #endif + + return status; + } + + + +template +inline +bool +auxlib::inv_sympd(Mat& out, const Base& X, const uword layout) + { + arma_extra_debug_sigprint(); + + out = X.get_ref(); + + arma_debug_check( (out.is_square() == false), "inv(): given matrix is not square" ); + + if(out.is_empty()) + { + return true; + } + + bool status; + + #if defined(ARMA_USE_LAPACK) + { + char uplo = (layout == 0) ? 'U' : 'L'; + blas_int n = blas_int(out.n_rows); + blas_int info = 0; + + lapack::potrf(&uplo, &n, out.memptr(), &n, &info); + + status = (info == 0); + + if(status == true) + { + lapack::potri(&uplo, &n, out.memptr(), &n, &info); + + out = (layout == 0) ? symmatu(out) : symmatl(out); + + status = (info == 0); + } + } + #else + { + arma_ignore(layout); + arma_stop("inv(): use of LAPACK needs to be enabled"); + status = false; + } + #endif + + return status; + } + + + +template +inline +eT +auxlib::det(const Base& X, const bool slow) + { + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_square() == false), "det(): matrix is not square" ); + + const bool make_copy = (is_Mat::value == true) ? true : false; + + if(slow == false) + { + const uword N = A.n_rows; + + switch(N) + { + case 0: + case 1: + case 2: + return auxlib::det_tinymat(A, N); + break; + + case 3: + case 4: + { + const eT tmp_det = auxlib::det_tinymat(A, N); + return (tmp_det != eT(0)) ? tmp_det : auxlib::det_lapack(A, make_copy); + } + break; + + default: + return auxlib::det_lapack(A, make_copy); + } + } + else + { + return auxlib::det_lapack(A, make_copy); + } + } + + + +template +inline +eT +auxlib::det_tinymat(const Mat& X, const uword N) + { + arma_extra_debug_sigprint(); + + switch(N) + { + case 0: + return eT(1); + break; + + case 1: + return X[0]; + break; + + case 2: + { + const eT* Xm = X.memptr(); + + return ( Xm[pos<0,0>::n2]*Xm[pos<1,1>::n2] - Xm[pos<0,1>::n2]*Xm[pos<1,0>::n2] ); + } + break; + + case 3: + { + // const double tmp1 = X.at(0,0) * X.at(1,1) * X.at(2,2); + // const double tmp2 = X.at(0,1) * X.at(1,2) * X.at(2,0); + // const double tmp3 = X.at(0,2) * X.at(1,0) * X.at(2,1); + // const double tmp4 = X.at(2,0) * X.at(1,1) * X.at(0,2); + // const double tmp5 = X.at(2,1) * X.at(1,2) * X.at(0,0); + // const double tmp6 = X.at(2,2) * X.at(1,0) * X.at(0,1); + // return (tmp1+tmp2+tmp3) - (tmp4+tmp5+tmp6); + + const eT* a_col0 = X.colptr(0); + const eT a11 = a_col0[0]; + const eT a21 = a_col0[1]; + const eT a31 = a_col0[2]; + + const eT* a_col1 = X.colptr(1); + const eT a12 = a_col1[0]; + const eT a22 = a_col1[1]; + const eT a32 = a_col1[2]; + + const eT* a_col2 = X.colptr(2); + const eT a13 = a_col2[0]; + const eT a23 = a_col2[1]; + const eT a33 = a_col2[2]; + + return ( a11*(a33*a22 - a32*a23) - a21*(a33*a12-a32*a13) + a31*(a23*a12 - a22*a13) ); + } + break; + + case 4: + { + const eT* Xm = X.memptr(); + + const eT val = \ + Xm[pos<0,3>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,0>::n4] \ + - Xm[pos<0,2>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,0>::n4] \ + - Xm[pos<0,3>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,0>::n4] \ + + Xm[pos<0,1>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,0>::n4] \ + + Xm[pos<0,2>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,0>::n4] \ + - Xm[pos<0,1>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,0>::n4] \ + - Xm[pos<0,3>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,1>::n4] \ + + Xm[pos<0,2>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,1>::n4] \ + + Xm[pos<0,3>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,1>::n4] \ + - Xm[pos<0,0>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,1>::n4] \ + - Xm[pos<0,2>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,1>::n4] \ + + Xm[pos<0,0>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,1>::n4] \ + + Xm[pos<0,3>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,2>::n4] \ + - Xm[pos<0,1>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,2>::n4] \ + - Xm[pos<0,3>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,2>::n4] \ + + Xm[pos<0,0>::n4] * Xm[pos<1,3>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,2>::n4] \ + + Xm[pos<0,1>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,2>::n4] \ + - Xm[pos<0,0>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,3>::n4] * Xm[pos<3,2>::n4] \ + - Xm[pos<0,2>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,3>::n4] \ + + Xm[pos<0,1>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,0>::n4] * Xm[pos<3,3>::n4] \ + + Xm[pos<0,2>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,3>::n4] \ + - Xm[pos<0,0>::n4] * Xm[pos<1,2>::n4] * Xm[pos<2,1>::n4] * Xm[pos<3,3>::n4] \ + - Xm[pos<0,1>::n4] * Xm[pos<1,0>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,3>::n4] \ + + Xm[pos<0,0>::n4] * Xm[pos<1,1>::n4] * Xm[pos<2,2>::n4] * Xm[pos<3,3>::n4] \ + ; + + return val; + } + break; + + default: + return eT(0); + ; + } + } + + + +//! immediate determinant of a matrix using ATLAS or LAPACK +template +inline +eT +auxlib::det_lapack(const Mat& X, const bool make_copy) + { + arma_extra_debug_sigprint(); + + Mat X_copy; + + if(make_copy == true) + { + X_copy = X; + } + + Mat& tmp = (make_copy == true) ? X_copy : const_cast< Mat& >(X); + + if(tmp.is_empty()) + { + return eT(1); + } + + + #if defined(ARMA_USE_ATLAS) + { + podarray ipiv(tmp.n_rows); + + //const int info = + atlas::clapack_getrf(atlas::CblasColMajor, tmp.n_rows, tmp.n_cols, tmp.memptr(), tmp.n_rows, ipiv.memptr()); + + // on output tmp appears to be L+U_alt, where U_alt is U with the main diagonal set to zero + eT val = tmp.at(0,0); + for(uword i=1; i < tmp.n_rows; ++i) + { + val *= tmp.at(i,i); + } + + int sign = +1; + for(uword i=0; i < tmp.n_rows; ++i) + { + if( int(i) != ipiv.mem[i] ) // NOTE: no adjustment required, as the clapack version of getrf() assumes counting from 0 + { + sign *= -1; + } + } + + return ( (sign < 0) ? -val : val ); + } + #elif defined(ARMA_USE_LAPACK) + { + podarray ipiv(tmp.n_rows); + + blas_int info = 0; + blas_int n_rows = blas_int(tmp.n_rows); + blas_int n_cols = blas_int(tmp.n_cols); + + lapack::getrf(&n_rows, &n_cols, tmp.memptr(), &n_rows, ipiv.memptr(), &info); + + // on output tmp appears to be L+U_alt, where U_alt is U with the main diagonal set to zero + eT val = tmp.at(0,0); + for(uword i=1; i < tmp.n_rows; ++i) + { + val *= tmp.at(i,i); + } + + blas_int sign = +1; + for(uword i=0; i < tmp.n_rows; ++i) + { + if( blas_int(i) != (ipiv.mem[i] - 1) ) // NOTE: adjustment of -1 is required as Fortran counts from 1 + { + sign *= -1; + } + } + + return ( (sign < 0) ? -val : val ); + } + #else + { + arma_ignore(X); + arma_ignore(make_copy); + arma_ignore(tmp); + arma_stop("det(): use of ATLAS or LAPACK needs to be enabled"); + return eT(0); + } + #endif + } + + + +//! immediate log determinant of a matrix using ATLAS or LAPACK +template +inline +bool +auxlib::log_det(eT& out_val, typename get_pod_type::result& out_sign, const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + #if defined(ARMA_USE_ATLAS) + { + Mat tmp(X.get_ref()); + arma_debug_check( (tmp.is_square() == false), "log_det(): given matrix is not square" ); + + if(tmp.is_empty()) + { + out_val = eT(0); + out_sign = T(1); + return true; + } + + podarray ipiv(tmp.n_rows); + + const int info = atlas::clapack_getrf(atlas::CblasColMajor, tmp.n_rows, tmp.n_cols, tmp.memptr(), tmp.n_rows, ipiv.memptr()); + + // on output tmp appears to be L+U_alt, where U_alt is U with the main diagonal set to zero + + sword sign = (is_complex::value == false) ? ( (access::tmp_real( tmp.at(0,0) ) < T(0)) ? -1 : +1 ) : +1; + eT val = (is_complex::value == false) ? std::log( (access::tmp_real( tmp.at(0,0) ) < T(0)) ? tmp.at(0,0)*T(-1) : tmp.at(0,0) ) : std::log( tmp.at(0,0) ); + + for(uword i=1; i < tmp.n_rows; ++i) + { + const eT x = tmp.at(i,i); + + sign *= (is_complex::value == false) ? ( (access::tmp_real(x) < T(0)) ? -1 : +1 ) : +1; + val += (is_complex::value == false) ? std::log( (access::tmp_real(x) < T(0)) ? x*T(-1) : x ) : std::log(x); + } + + for(uword i=0; i < tmp.n_rows; ++i) + { + if( int(i) != ipiv.mem[i] ) // NOTE: no adjustment required, as the clapack version of getrf() assumes counting from 0 + { + sign *= -1; + } + } + + out_val = val; + out_sign = T(sign); + + return (info == 0); + } + #elif defined(ARMA_USE_LAPACK) + { + Mat tmp(X.get_ref()); + arma_debug_check( (tmp.is_square() == false), "log_det(): given matrix is not square" ); + + if(tmp.is_empty()) + { + out_val = eT(0); + out_sign = T(1); + return true; + } + + podarray ipiv(tmp.n_rows); + + blas_int info = 0; + blas_int n_rows = blas_int(tmp.n_rows); + blas_int n_cols = blas_int(tmp.n_cols); + + lapack::getrf(&n_rows, &n_cols, tmp.memptr(), &n_rows, ipiv.memptr(), &info); + + // on output tmp appears to be L+U_alt, where U_alt is U with the main diagonal set to zero + + sword sign = (is_complex::value == false) ? ( (access::tmp_real( tmp.at(0,0) ) < T(0)) ? -1 : +1 ) : +1; + eT val = (is_complex::value == false) ? std::log( (access::tmp_real( tmp.at(0,0) ) < T(0)) ? tmp.at(0,0)*T(-1) : tmp.at(0,0) ) : std::log( tmp.at(0,0) ); + + for(uword i=1; i < tmp.n_rows; ++i) + { + const eT x = tmp.at(i,i); + + sign *= (is_complex::value == false) ? ( (access::tmp_real(x) < T(0)) ? -1 : +1 ) : +1; + val += (is_complex::value == false) ? std::log( (access::tmp_real(x) < T(0)) ? x*T(-1) : x ) : std::log(x); + } + + for(uword i=0; i < tmp.n_rows; ++i) + { + if( blas_int(i) != (ipiv.mem[i] - 1) ) // NOTE: adjustment of -1 is required as Fortran counts from 1 + { + sign *= -1; + } + } + + out_val = val; + out_sign = T(sign); + + return (info == 0); + } + #else + { + out_val = eT(0); + out_sign = T(0); + + arma_stop("log_det(): use of ATLAS or LAPACK needs to be enabled"); + + return false; + } + #endif + } + + + +//! immediate LU decomposition of a matrix using ATLAS or LAPACK +template +inline +bool +auxlib::lu(Mat& L, Mat& U, podarray& ipiv, const Base& X) + { + arma_extra_debug_sigprint(); + + U = X.get_ref(); + + const uword U_n_rows = U.n_rows; + const uword U_n_cols = U.n_cols; + + if(U.is_empty()) + { + L.set_size(U_n_rows, 0); + U.set_size(0, U_n_cols); + ipiv.reset(); + return true; + } + + #if defined(ARMA_USE_ATLAS) || defined(ARMA_USE_LAPACK) + { + bool status; + + #if defined(ARMA_USE_ATLAS) + { + ipiv.set_size( (std::min)(U_n_rows, U_n_cols) ); + + int info = atlas::clapack_getrf(atlas::CblasColMajor, U_n_rows, U_n_cols, U.memptr(), U_n_rows, ipiv.memptr()); + + status = (info == 0); + } + #elif defined(ARMA_USE_LAPACK) + { + ipiv.set_size( (std::min)(U_n_rows, U_n_cols) ); + + blas_int info = 0; + + blas_int n_rows = U_n_rows; + blas_int n_cols = U_n_cols; + + + lapack::getrf(&n_rows, &n_cols, U.memptr(), &n_rows, ipiv.memptr(), &info); + + // take into account that Fortran counts from 1 + arrayops::inplace_minus(ipiv.memptr(), blas_int(1), ipiv.n_elem); + + status = (info == 0); + } + #endif + + L.copy_size(U); + + for(uword col=0; col < U_n_cols; ++col) + { + for(uword row=0; (row < col) && (row < U_n_rows); ++row) + { + L.at(row,col) = eT(0); + } + + if( L.in_range(col,col) == true ) + { + L.at(col,col) = eT(1); + } + + for(uword row = (col+1); row < U_n_rows; ++row) + { + L.at(row,col) = U.at(row,col); + U.at(row,col) = eT(0); + } + } + + return status; + } + #else + { + arma_stop("lu(): use of ATLAS or LAPACK needs to be enabled"); + + return false; + } + #endif + } + + + +template +inline +bool +auxlib::lu(Mat& L, Mat& U, Mat& P, const Base& X) + { + arma_extra_debug_sigprint(); + + podarray ipiv1; + const bool status = auxlib::lu(L, U, ipiv1, X); + + if(status == true) + { + if(U.is_empty()) + { + // L and U have been already set to the correct empty matrices + P.eye(L.n_rows, L.n_rows); + return true; + } + + const uword n = ipiv1.n_elem; + const uword P_rows = U.n_rows; + + podarray ipiv2(P_rows); + + const blas_int* ipiv1_mem = ipiv1.memptr(); + blas_int* ipiv2_mem = ipiv2.memptr(); + + for(uword i=0; i(ipiv1_mem[i]); + + if( ipiv2_mem[i] != ipiv2_mem[k] ) + { + std::swap( ipiv2_mem[i], ipiv2_mem[k] ); + } + } + + P.zeros(P_rows, P_rows); + + for(uword row=0; row(ipiv2_mem[row])) = eT(1); + } + + if(L.n_cols > U.n_rows) + { + L.shed_cols(U.n_rows, L.n_cols-1); + } + + if(U.n_rows > L.n_cols) + { + U.shed_rows(L.n_cols, U.n_rows-1); + } + } + + return status; + } + + + +template +inline +bool +auxlib::lu(Mat& L, Mat& U, const Base& X) + { + arma_extra_debug_sigprint(); + + podarray ipiv1; + const bool status = auxlib::lu(L, U, ipiv1, X); + + if(status == true) + { + if(U.is_empty()) + { + // L and U have been already set to the correct empty matrices + return true; + } + + const uword n = ipiv1.n_elem; + const uword P_rows = U.n_rows; + + podarray ipiv2(P_rows); + + const blas_int* ipiv1_mem = ipiv1.memptr(); + blas_int* ipiv2_mem = ipiv2.memptr(); + + for(uword i=0; i(ipiv1_mem[i]); + + if( ipiv2_mem[i] != ipiv2_mem[k] ) + { + std::swap( ipiv2_mem[i], ipiv2_mem[k] ); + L.swap_rows( static_cast(ipiv2_mem[i]), static_cast(ipiv2_mem[k]) ); + } + } + + if(L.n_cols > U.n_rows) + { + L.shed_cols(U.n_rows, L.n_cols-1); + } + + if(U.n_rows > L.n_cols) + { + U.shed_rows(L.n_cols, U.n_rows-1); + } + } + + return status; + } + + + +//! immediate eigenvalues of a symmetric real matrix using LAPACK +template +inline +bool +auxlib::eig_sym(Col& eigval, const Base& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + arma_debug_check( (A.is_square() == false), "eig_sym(): given matrix is not square"); + + if(A.is_empty()) + { + eigval.reset(); + return true; + } + + // rudimentary "better-than-nothing" test for symmetry + //arma_debug_check( (A.at(A.n_rows-1, 0) != A.at(0, A.n_cols-1)), "auxlib::eig(): given matrix is not symmetric" ); + + char jobz = 'N'; + char uplo = 'U'; + + blas_int n_rows = A.n_rows; + blas_int lwork = (std::max)(blas_int(1), 3*n_rows-1); + + eigval.set_size( static_cast(n_rows) ); + podarray work( static_cast(lwork) ); + + blas_int info; + + arma_extra_debug_print("lapack::syev()"); + lapack::syev(&jobz, &uplo, &n_rows, A.memptr(), &n_rows, eigval.memptr(), work.memptr(), &lwork, &info); + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(X); + arma_stop("eig_sym(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +//! immediate eigenvalues of a hermitian complex matrix using LAPACK +template +inline +bool +auxlib::eig_sym(Col& eigval, const Base,T1>& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + arma_debug_check( (A.is_square() == false), "eig_sym(): given matrix is not hermitian"); + + if(A.is_empty()) + { + eigval.reset(); + return true; + } + + char jobz = 'N'; + char uplo = 'U'; + + blas_int n_rows = A.n_rows; + blas_int lda = A.n_rows; + blas_int lwork = (std::max)(blas_int(1), 2*n_rows - 1); // TODO: automatically find best size of lwork + + eigval.set_size( static_cast(n_rows) ); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast((std::max)(blas_int(1), 3*n_rows - 2)) ); + + blas_int info; + + arma_extra_debug_print("lapack::heev()"); + lapack::heev(&jobz, &uplo, &n_rows, A.memptr(), &lda, eigval.memptr(), work.memptr(), &lwork, rwork.memptr(), &info); + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(X); + arma_stop("eig_sym(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +//! immediate eigenvalues and eigenvectors of a symmetric real matrix using LAPACK +template +inline +bool +auxlib::eig_sym(Col& eigval, Mat& eigvec, const Base& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + eigvec = X.get_ref(); + + arma_debug_check( (eigvec.is_square() == false), "eig_sym(): given matrix is not square" ); + + if(eigvec.is_empty()) + { + eigval.reset(); + eigvec.reset(); + return true; + } + + // rudimentary "better-than-nothing" test for symmetry + //arma_debug_check( (A.at(A.n_rows-1, 0) != A.at(0, A.n_cols-1)), "auxlib::eig(): given matrix is not symmetric" ); + + char jobz = 'V'; + char uplo = 'U'; + + blas_int n_rows = eigvec.n_rows; + blas_int lwork = (std::max)(blas_int(1), 3*n_rows-1); + + eigval.set_size( static_cast(n_rows) ); + podarray work( static_cast(lwork) ); + + blas_int info; + + arma_extra_debug_print("lapack::syev()"); + lapack::syev(&jobz, &uplo, &n_rows, eigvec.memptr(), &n_rows, eigval.memptr(), work.memptr(), &lwork, &info); + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(eigvec); + arma_stop("eig_sym(): use of LAPACK needs to be enabled"); + + return false; + } + #endif + } + + + +//! immediate eigenvalues and eigenvectors of a hermitian complex matrix using LAPACK +template +inline +bool +auxlib::eig_sym(Col& eigval, Mat< std::complex >& eigvec, const Base,T1>& X) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + eigvec = X.get_ref(); + + arma_debug_check( (eigvec.is_square() == false), "eig_sym(): given matrix is not hermitian" ); + + if(eigvec.is_empty()) + { + eigval.reset(); + eigvec.reset(); + return true; + } + + char jobz = 'V'; + char uplo = 'U'; + + blas_int n_rows = eigvec.n_rows; + blas_int lda = eigvec.n_rows; + blas_int lwork = (std::max)(blas_int(1), 2*n_rows - 1); // TODO: automatically find best size of lwork + + eigval.set_size( static_cast(n_rows) ); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast((std::max)(blas_int(1), 3*n_rows - 2)) ); + + blas_int info; + + arma_extra_debug_print("lapack::heev()"); + lapack::heev(&jobz, &uplo, &n_rows, eigvec.memptr(), &lda, eigval.memptr(), work.memptr(), &lwork, rwork.memptr(), &info); + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(eigvec); + arma_ignore(X); + arma_stop("eig_sym(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +//! Eigenvalues and eigenvectors of a general square real matrix using LAPACK. +//! The argument 'side' specifies which eigenvectors should be calculated +//! (see code for mode details). +template +inline +bool +auxlib::eig_gen + ( + Col< std::complex >& eigval, + Mat& l_eigvec, + Mat& r_eigvec, + const Base& X, + const char side + ) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + char jobvl; + char jobvr; + + switch(side) + { + case 'l': // left + jobvl = 'V'; + jobvr = 'N'; + break; + + case 'r': // right + jobvl = 'N'; + jobvr = 'V'; + break; + + case 'b': // both + jobvl = 'V'; + jobvr = 'V'; + break; + + case 'n': // neither + jobvl = 'N'; + jobvr = 'N'; + break; + + default: + arma_stop("eig_gen(): parameter 'side' is invalid"); + return false; + } + + Mat A(X.get_ref()); + arma_debug_check( (A.is_square() == false), "eig_gen(): given matrix is not square" ); + + if(A.is_empty()) + { + eigval.reset(); + l_eigvec.reset(); + r_eigvec.reset(); + return true; + } + + uword A_n_rows = A.n_rows; + + blas_int n_rows = A_n_rows; + blas_int lda = A_n_rows; + blas_int lwork = (std::max)(blas_int(1), 4*n_rows); // TODO: automatically find best size of lwork + + eigval.set_size(A_n_rows); + l_eigvec.set_size(A_n_rows, A_n_rows); + r_eigvec.set_size(A_n_rows, A_n_rows); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast((std::max)(blas_int(1), 3*n_rows)) ); + + podarray wr(A_n_rows); + podarray wi(A_n_rows); + + Mat A_copy = A; + blas_int info; + + arma_extra_debug_print("lapack::geev()"); + lapack::geev(&jobvl, &jobvr, &n_rows, A_copy.memptr(), &lda, wr.memptr(), wi.memptr(), l_eigvec.memptr(), &n_rows, r_eigvec.memptr(), &n_rows, work.memptr(), &lwork, &info); + + + eigval.set_size(A_n_rows); + for(uword i=0; i(wr[i], wi[i]); + } + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(l_eigvec); + arma_ignore(r_eigvec); + arma_ignore(X); + arma_ignore(side); + arma_stop("eig_gen(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + + + +//! Eigenvalues and eigenvectors of a general square complex matrix using LAPACK +//! The argument 'side' specifies which eigenvectors should be calculated +//! (see code for mode details). +template +inline +bool +auxlib::eig_gen + ( + Col< std::complex >& eigval, + Mat< std::complex >& l_eigvec, + Mat< std::complex >& r_eigvec, + const Base< std::complex, T1 >& X, + const char side + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + char jobvl; + char jobvr; + + switch(side) + { + case 'l': // left + jobvl = 'V'; + jobvr = 'N'; + break; + + case 'r': // right + jobvl = 'N'; + jobvr = 'V'; + break; + + case 'b': // both + jobvl = 'V'; + jobvr = 'V'; + break; + + case 'n': // neither + jobvl = 'N'; + jobvr = 'N'; + break; + + default: + arma_stop("eig_gen(): parameter 'side' is invalid"); + return false; + } + + Mat A(X.get_ref()); + arma_debug_check( (A.is_square() == false), "eig_gen(): given matrix is not square" ); + + if(A.is_empty()) + { + eigval.reset(); + l_eigvec.reset(); + r_eigvec.reset(); + return true; + } + + uword A_n_rows = A.n_rows; + + blas_int n_rows = A_n_rows; + blas_int lda = A_n_rows; + blas_int lwork = (std::max)(blas_int(1), 4*n_rows); // TODO: automatically find best size of lwork + + eigval.set_size(A_n_rows); + l_eigvec.set_size(A_n_rows, A_n_rows); + r_eigvec.set_size(A_n_rows, A_n_rows); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast((std::max)(blas_int(1), 3*n_rows)) ); // was 2,3 + + blas_int info; + + arma_extra_debug_print("lapack::cx_geev()"); + lapack::cx_geev(&jobvl, &jobvr, &n_rows, A.memptr(), &lda, eigval.memptr(), l_eigvec.memptr(), &n_rows, r_eigvec.memptr(), &n_rows, work.memptr(), &lwork, rwork.memptr(), &info); + + return (info == 0); + } + #else + { + arma_ignore(eigval); + arma_ignore(l_eigvec); + arma_ignore(r_eigvec); + arma_ignore(X); + arma_ignore(side); + arma_stop("eig_gen(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::chol(Mat& out, const Base& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + out = X.get_ref(); + + arma_debug_check( (out.is_square() == false), "chol(): given matrix is not square" ); + + if(out.is_empty()) + { + return true; + } + + const uword out_n_rows = out.n_rows; + + char uplo = 'U'; + blas_int n = out_n_rows; + blas_int info; + + lapack::potrf(&uplo, &n, out.memptr(), &n, &info); + + for(uword col=0; col +inline +bool +auxlib::qr(Mat& Q, Mat& R, const Base& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + R = X.get_ref(); + + const uword R_n_rows = R.n_rows; + const uword R_n_cols = R.n_cols; + + if(R.is_empty()) + { + Q.eye(R_n_rows, R_n_rows); + return true; + } + + blas_int m = static_cast(R_n_rows); + blas_int n = static_cast(R_n_cols); + blas_int work_len = (std::max)(blas_int(1),n); + blas_int work_len_tmp; + blas_int k = (std::min)(m,n); + blas_int info; + + podarray tau( static_cast(k) ); + podarray work( static_cast(work_len) ); + + // query for the optimum value of work_len + work_len_tmp = -1; + lapack::geqrf(&m, &n, R.memptr(), &m, tau.memptr(), work.memptr(), &work_len_tmp, &info); + + if(info == 0) + { + work_len = static_cast(access::tmp_real(work[0])); + work.set_size( static_cast(work_len) ); + } + + lapack::geqrf(&m, &n, R.memptr(), &m, tau.memptr(), work.memptr(), &work_len, &info); + + Q.set_size(R_n_rows, R_n_rows); + + arrayops::copy( Q.memptr(), R.memptr(), (std::min)(Q.n_elem, R.n_elem) ); + + // + // construct R + + for(uword col=0; col < R_n_cols; ++col) + { + for(uword row=(col+1); row < R_n_rows; ++row) + { + R.at(row,col) = eT(0); + } + } + + + if( (is_float::value == true) || (is_double::value == true) ) + { + // query for the optimum value of work_len + work_len_tmp = -1; + lapack::orgqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &work_len_tmp, &info); + + if(info == 0) + { + work_len = static_cast(access::tmp_real(work[0])); + work.set_size( static_cast(work_len) ); + } + + lapack::orgqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &work_len, &info); + } + else + if( (is_supported_complex_float::value == true) || (is_supported_complex_double::value == true) ) + { + // query for the optimum value of work_len + work_len_tmp = -1; + lapack::ungqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &work_len_tmp, &info); + + if(info == 0) + { + work_len = static_cast(access::tmp_real(work[0])); + work.set_size( static_cast(work_len) ); + } + + lapack::ungqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &work_len, &info); + } + + return (info == 0); + } + #else + { + arma_ignore(Q); + arma_ignore(R); + arma_ignore(X); + arma_stop("qr(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::svd(Col& S, const Base& X, uword& X_n_rows, uword& X_n_cols) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + X_n_rows = A.n_rows; + X_n_cols = A.n_cols; + + if(A.is_empty()) + { + S.reset(); + return true; + } + + Mat U(1, 1); + Mat V(1, A.n_cols); + + char jobu = 'N'; + char jobvt = 'N'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldu = U.n_rows; + blas_int ldvt = V.n_rows; + blas_int lwork = 2 * (std::max)(blas_int(1), (std::max)( (3*(std::min)(m,n) + (std::max)(m,n)), 5*(std::min)(m,n) ) ); + blas_int info; + + S.set_size( static_cast((std::min)(m, n)) ); + + podarray work( static_cast(lwork) ); + + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + + lapack::gesvd + ( + &jobu, &jobvt, + &m,&n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(work[0]); + + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + &info + ); + } + + return (info == 0); + } + #else + { + arma_ignore(S); + arma_ignore(X); + arma_ignore(X_n_rows); + arma_ignore(X_n_cols); + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::svd(Col& S, const Base, T1>& X, uword& X_n_rows, uword& X_n_cols) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + X_n_rows = A.n_rows; + X_n_cols = A.n_cols; + + if(A.is_empty()) + { + S.reset(); + return true; + } + + Mat U(1, 1); + Mat V(1, A.n_cols); + + char jobu = 'N'; + char jobvt = 'N'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldu = U.n_rows; + blas_int ldvt = V.n_rows; + blas_int lwork = 2 * (std::max)(blas_int(1), 2*(std::min)(m,n)+(std::max)(m,n) ); + blas_int info; + + S.set_size( static_cast((std::min)(m,n)) ); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast(5*(std::min)(m,n)) ); + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + rwork.memptr(), + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(real(work[0])); + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + rwork.memptr(), + &info + ); + } + + return (info == 0); + } + #else + { + arma_ignore(S); + arma_ignore(X); + arma_ignore(X_n_rows); + arma_ignore(X_n_cols); + + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::svd(Col& S, const Base& X) + { + arma_extra_debug_sigprint(); + + uword junk; + return auxlib::svd(S, X, junk, junk); + } + + + +template +inline +bool +auxlib::svd(Col& S, const Base, T1>& X) + { + arma_extra_debug_sigprint(); + + uword junk; + return auxlib::svd(S, X, junk, junk); + } + + + +template +inline +bool +auxlib::svd(Mat& U, Col& S, Mat& V, const Base& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + if(A.is_empty()) + { + U.eye(A.n_rows, A.n_rows); + S.reset(); + V.eye(A.n_cols, A.n_cols); + return true; + } + + U.set_size(A.n_rows, A.n_rows); + V.set_size(A.n_cols, A.n_cols); + + char jobu = 'A'; + char jobvt = 'A'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldu = U.n_rows; + blas_int ldvt = V.n_rows; + blas_int lwork = 2 * (std::max)(blas_int(1), (std::max)( (3*(std::min)(m,n) + (std::max)(m,n)), 5*(std::min)(m,n) ) ); + blas_int info; + + + S.set_size( static_cast((std::min)(m,n)) ); + podarray work( static_cast(lwork) ); + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + + lapack::gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(work[0]); + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + &info + ); + + op_strans::apply(V,V); // op_strans will work out that an in-place transpose can be done + } + + return (info == 0); + } + #else + { + arma_ignore(U); + arma_ignore(S); + arma_ignore(V); + arma_ignore(X); + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::svd(Mat< std::complex >& U, Col& S, Mat< std::complex >& V, const Base< std::complex, T1>& X) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + if(A.is_empty()) + { + U.eye(A.n_rows, A.n_rows); + S.reset(); + V.eye(A.n_cols, A.n_cols); + return true; + } + + U.set_size(A.n_rows, A.n_rows); + V.set_size(A.n_cols, A.n_cols); + + char jobu = 'A'; + char jobvt = 'A'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldu = U.n_rows; + blas_int ldvt = V.n_rows; + blas_int lwork = 2 * (std::max)(blas_int(1), 2*(std::min)(m,n)+(std::max)(m,n) ); + blas_int info; + + S.set_size( static_cast((std::min)(m,n)) ); + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast(5*(std::min)(m,n)) ); + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + rwork.memptr(), + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(real(work[0])); + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + rwork.memptr(), + &info + ); + + op_htrans::apply(V,V); // op_htrans will work out that an in-place transpose can be done + } + + return (info == 0); + } + #else + { + arma_ignore(U); + arma_ignore(S); + arma_ignore(V); + arma_ignore(X); + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + + } + + + +template +inline +bool +auxlib::svd_econ(Mat& U, Col& S, Mat& V, const Base& X, const char mode) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + + S.set_size( static_cast((std::min)(m,n)) ); + + blas_int ldu = 0; + blas_int ldvt = 0; + + char jobu; + char jobvt; + + switch(mode) + { + case 'l': + jobu = 'S'; + jobvt = 'N'; + + ldu = m; + ldvt = 1; + + U.set_size( static_cast(ldu), static_cast((std::min)(m,n)) ); + V.reset(); + + break; + + + case 'r': + jobu = 'N'; + jobvt = 'S'; + + ldu = 1; + ldvt = (std::min)(m,n); + + U.reset(); + V.set_size( static_cast(ldvt), static_cast(n) ); + + break; + + + case 'b': + jobu = 'S'; + jobvt = 'S'; + + ldu = m; + ldvt = (std::min)(m,n); + + U.set_size( static_cast(ldu), static_cast((std::min)(m,n)) ); + V.set_size( static_cast(ldvt), static_cast(n) ); + + break; + + + default: + U.reset(); + S.reset(); + V.reset(); + return false; + } + + + if(A.is_empty()) + { + U.eye(); + S.reset(); + V.eye(); + return true; + } + + + blas_int lwork = 2 * (std::max)(blas_int(1), (std::max)( (3*(std::min)(m,n) + (std::max)(m,n)), 5*(std::min)(m,n) ) ); + blas_int info = 0; + + + podarray work( static_cast(lwork) ); + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + + lapack::gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(work[0]); + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + &info + ); + + op_strans::apply(V,V); // op_strans will work out that an in-place transpose can be done + } + + return (info == 0); + } + #else + { + arma_ignore(U); + arma_ignore(S); + arma_ignore(V); + arma_ignore(X); + arma_ignore(mode); + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::svd_econ(Mat< std::complex >& U, Col& S, Mat< std::complex >& V, const Base< std::complex, T1>& X, const char mode) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + #if defined(ARMA_USE_LAPACK) + { + Mat A(X.get_ref()); + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + + S.set_size( static_cast((std::min)(m,n)) ); + + blas_int ldu = 0; + blas_int ldvt = 0; + + char jobu; + char jobvt; + + switch(mode) + { + case 'l': + jobu = 'S'; + jobvt = 'N'; + + ldu = m; + ldvt = 1; + + U.set_size( static_cast(ldu), static_cast((std::min)(m,n)) ); + V.reset(); + + break; + + + case 'r': + jobu = 'N'; + jobvt = 'S'; + + ldu = 1; + ldvt = (std::min)(m,n); + + U.reset(); + V.set_size( static_cast(ldvt), static_cast(n) ); + + break; + + + case 'b': + jobu = 'S'; + jobvt = 'S'; + + ldu = m; + ldvt = (std::min)(m,n); + + U.set_size( static_cast(ldu), static_cast((std::min)(m,n)) ); + V.set_size( static_cast(ldvt), static_cast(n) ); + + break; + + + default: + U.reset(); + S.reset(); + V.reset(); + return false; + } + + + if(A.is_empty()) + { + U.eye(); + S.reset(); + V.eye(); + return true; + } + + + blas_int lwork = 2 * (std::max)(blas_int(1), (std::max)( (3*(std::min)(m,n) + (std::max)(m,n)), 5*(std::min)(m,n) ) ); + blas_int info = 0; + + + podarray work( static_cast(lwork) ); + podarray rwork( static_cast(5*(std::min)(m,n)) ); + + // let gesvd_() calculate the optimum size of the workspace + blas_int lwork_tmp = -1; + + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork_tmp, + rwork.memptr(), + &info + ); + + if(info == 0) + { + blas_int proposed_lwork = static_cast(real(work[0])); + if(proposed_lwork > lwork) + { + lwork = proposed_lwork; + work.set_size( static_cast(lwork) ); + } + + lapack::cx_gesvd + ( + &jobu, &jobvt, + &m, &n, + A.memptr(), &lda, + S.memptr(), + U.memptr(), &ldu, + V.memptr(), &ldvt, + work.memptr(), &lwork, + rwork.memptr(), + &info + ); + + op_htrans::apply(V,V); // op_strans will work out that an in-place transpose can be done + } + + return (info == 0); + } + #else + { + arma_ignore(U); + arma_ignore(S); + arma_ignore(V); + arma_ignore(X); + arma_ignore(mode); + arma_stop("svd(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +//! Solve a system of linear equations. +//! Assumes that A.n_rows = A.n_cols and B.n_rows = A.n_rows +template +inline +bool +auxlib::solve(Mat& out, Mat& A, const Mat& B, const bool slow) + { + arma_extra_debug_sigprint(); + + if(A.is_empty() || B.is_empty()) + { + out.zeros(A.n_cols, B.n_cols); + return true; + } + else + { + const uword A_n_rows = A.n_rows; + + bool status = false; + + if( (A_n_rows <= 4) && (slow == false) ) + { + Mat A_inv; + + status = auxlib::inv_noalias_tinymat(A_inv, A, A_n_rows); + + if(status == true) + { + out.set_size(A_n_rows, B.n_cols); + + gemm_emul::apply(out, A_inv, B); + + return true; + } + } + + if( (A_n_rows > 4) || (status == false) ) + { + #if defined(ARMA_USE_ATLAS) + { + podarray ipiv(A_n_rows); + + out = B; + + int info = atlas::clapack_gesv(atlas::CblasColMajor, A_n_rows, B.n_cols, A.memptr(), A_n_rows, ipiv.memptr(), out.memptr(), A_n_rows); + + return (info == 0); + } + #elif defined(ARMA_USE_LAPACK) + { + blas_int n = A_n_rows; + blas_int lda = A_n_rows; + blas_int ldb = A_n_rows; + blas_int nrhs = B.n_cols; + blas_int info; + + podarray ipiv(A_n_rows); + + out = B; + + lapack::gesv(&n, &nrhs, A.memptr(), &lda, ipiv.memptr(), out.memptr(), &ldb, &info); + + return (info == 0); + } + #else + { + arma_stop("solve(): use of ATLAS or LAPACK needs to be enabled"); + return false; + } + #endif + } + } + + return true; + } + + + +//! Solve an over-determined system. +//! Assumes that A.n_rows > A.n_cols and B.n_rows = A.n_rows +template +inline +bool +auxlib::solve_od(Mat& out, Mat& A, const Mat& B) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + if(A.is_empty() || B.is_empty()) + { + out.zeros(A.n_cols, B.n_cols); + return true; + } + + char trans = 'N'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldb = A.n_rows; + blas_int nrhs = B.n_cols; + blas_int lwork = n + (std::max)(n, nrhs); + blas_int info; + + Mat tmp = B; + + podarray work( static_cast(lwork) ); + + arma_extra_debug_print("lapack::gels()"); + + // NOTE: the dgels() function in the lapack library supplied by ATLAS 3.6 seems to have problems + + lapack::gels + ( + &trans, &m, &n, &nrhs, + A.memptr(), &lda, + tmp.memptr(), &ldb, + work.memptr(), &lwork, + &info + ); + + arma_extra_debug_print("lapack::gels() -- finished"); + + out.set_size(A.n_cols, B.n_cols); + + for(uword col=0; col +inline +bool +auxlib::solve_ud(Mat& out, Mat& A, const Mat& B) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + if(A.is_empty() || B.is_empty()) + { + out.zeros(A.n_cols, B.n_cols); + return true; + } + + char trans = 'N'; + + blas_int m = A.n_rows; + blas_int n = A.n_cols; + blas_int lda = A.n_rows; + blas_int ldb = A.n_cols; + blas_int nrhs = B.n_cols; + blas_int lwork = m + (std::max)(m,nrhs); + blas_int info; + + + Mat tmp; + tmp.zeros(A.n_cols, B.n_cols); + + for(uword col=0; col work( static_cast(lwork) ); + + arma_extra_debug_print("lapack::gels()"); + + // NOTE: the dgels() function in the lapack library supplied by ATLAS 3.6 seems to have problems + + lapack::gels + ( + &trans, &m, &n, &nrhs, + A.memptr(), &lda, + tmp.memptr(), &ldb, + work.memptr(), &lwork, + &info + ); + + arma_extra_debug_print("lapack::gels() -- finished"); + + out.set_size(A.n_cols, B.n_cols); + + for(uword col=0; col +inline +bool +auxlib::solve_tr(Mat& out, const Mat& A, const Mat& B, const uword layout) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + if(A.is_empty() || B.is_empty()) + { + out.zeros(A.n_cols, B.n_cols); + return true; + } + + out = B; + + char uplo = (layout == 0) ? 'U' : 'L'; + char trans = 'N'; + char diag = 'N'; + blas_int n = blas_int(A.n_rows); + blas_int nrhs = blas_int(B.n_cols); + blas_int info = 0; + + lapack::trtrs(&uplo, &trans, &diag, &n, &nrhs, A.memptr(), &n, out.memptr(), &n, &info); + + return (info == 0); + } + #else + { + arma_ignore(out); + arma_ignore(A); + arma_ignore(B); + arma_ignore(layout); + arma_stop("solve(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +// +// Schur decomposition + +template +inline +bool +auxlib::schur_dec(Mat& Z, Mat& T, const Mat& A) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + arma_debug_check( (A.is_square() == false), "schur_dec(): given matrix is not square" ); + + if(A.is_empty()) + { + Z.reset(); + T.reset(); + return true; + } + + const uword A_n_rows = A.n_rows; + + char jobvs = 'V'; // get Schur vectors (Z) + char sort = 'N'; // do not sort eigenvalues/vectors + blas_int* select = 0; // pointer to sorting function + blas_int n = blas_int(A_n_rows); + blas_int sdim = 0; // output for sorting + + blas_int lwork = 3 * n; // workspace must be at least 3 * n (if set to -1, optimal size is output in work(0) and nothing else is done + + podarray work( static_cast(lwork) ); + podarray bwork(A_n_rows); + + blas_int info = 0; + + Z.set_size(A_n_rows, A_n_rows); + T = A; + + podarray wr(A_n_rows); // output for eigenvalues + podarray wi(A_n_rows); // output for eigenvalues + + lapack::gees(&jobvs, &sort, select, &n, T.memptr(), &n, &sdim, wr.memptr(), wi.memptr(), Z.memptr(), &n, work.memptr(), &lwork, bwork.memptr(), &info); + + return (info == 0); + } + #else + { + arma_ignore(Z); + arma_ignore(T); + arma_stop("schur_dec(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +template +inline +bool +auxlib::schur_dec(Mat >& Z, Mat >& T, const Mat >& A) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + arma_debug_check( (A.is_square() == false), "schur_dec(): matrix A is not square" ); + + if(A.is_empty()) + { + Z.reset(); + T.reset(); + return true; + } + + typedef std::complex eT; + + const uword A_n_rows = A.n_rows; + + char jobvs = 'V'; // get Schur vectors (Z) + char sort = 'N'; // do not sort eigenvalues/vectors + blas_int* select = 0; // pointer to sorting function + blas_int n = blas_int(A_n_rows); + blas_int sdim = 0; // output for sorting + + blas_int lwork = 3 * n; // workspace must be at least 3 * n (if set to -1, optimal size is output in work(0) and nothing else is done + + podarray work( static_cast(lwork) ); + podarray bwork(A_n_rows); + + blas_int info = 0; + + Z.set_size(A_n_rows, A_n_rows); + T = A; + + podarray w(A_n_rows); // output for eigenvalues + podarray rwork(A_n_rows); + + lapack::cx_gees(&jobvs, &sort, select, &n, T.memptr(), &n, &sdim, w.memptr(), Z.memptr(), &n, work.memptr(), &lwork, rwork.memptr(), bwork.memptr(), &info); + + return (info == 0); + } + #else + { + arma_ignore(Z); + arma_ignore(T); + arma_stop("schur_dec(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +// +// syl (solution of the Sylvester equation AX + XB = C) + +template +inline +bool +auxlib::syl(Mat& X, const Mat& A, const Mat& B, const Mat& C) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (A.is_square() == false) || (B.is_square() == false), + "syl(): given matrix is not square" + ); + + arma_debug_check + ( + (C.n_rows != A.n_rows) || (C.n_cols != B.n_cols), + "syl(): matrices are not conformant" + ); + + if(A.is_empty() || B.is_empty() || C.is_empty()) + { + X.reset(); + return true; + } + + #if defined(ARMA_USE_LAPACK) + { + Mat Z1, Z2, T1, T2; + + const bool status_sd1 = auxlib::schur_dec(Z1, T1, A); + const bool status_sd2 = auxlib::schur_dec(Z2, T2, B); + + if( (status_sd1 == false) || (status_sd2 == false) ) + { + return false; + } + + char trana = 'N'; + char tranb = 'N'; + blas_int isgn = +1; + blas_int m = blas_int(T1.n_rows); + blas_int n = blas_int(T2.n_cols); + + eT scale = eT(0); + blas_int info = 0; + + Mat Y = trans(Z1) * C * Z2; + + lapack::trsyl(&trana, &tranb, &isgn, &m, &n, T1.memptr(), &m, T2.memptr(), &n, Y.memptr(), &m, &scale, &info); + + //Y /= scale; + Y /= (-scale); + + X = Z1 * Y * trans(Z2); + + return (info >= 0); + } + #else + { + arma_stop("syl(): use of LAPACK needs to be enabled"); + return false; + } + #endif + } + + + +// +// lyap (solution of the continuous Lyapunov equation AX + XA^H + Q = 0) + +template +inline +bool +auxlib::lyap(Mat& X, const Mat& A, const Mat& Q) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.is_square() == false), "lyap(): matrix A is not square"); + arma_debug_check( (Q.is_square() == false), "lyap(): matrix Q is not square"); + arma_debug_check( (A.n_rows != Q.n_rows), "lyap(): matrices A and Q have different dimensions"); + + Mat htransA; + op_htrans::apply_noalias(htransA, A); + + const Mat mQ = -Q; + + return auxlib::syl(X, A, htransA, mQ); + } + + + +// +// dlyap (solution of the discrete Lyapunov equation AXA^H - X + Q = 0) + +template +inline +bool +auxlib::dlyap(Mat& X, const Mat& A, const Mat& Q) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.is_square() == false), "dlyap(): matrix A is not square"); + arma_debug_check( (Q.is_square() == false), "dlyap(): matrix Q is not square"); + arma_debug_check( (A.n_rows != Q.n_rows), "dlyap(): matrices A and Q have different dimensions"); + + const Col vecQ = reshape(Q, Q.n_elem, 1); + + const Mat M = eye< Mat >(Q.n_elem, Q.n_elem) - kron(conj(A), A); + + Col vecX; + + const bool status = solve(vecX, M, vecQ); + + if(status == true) + { + X = reshape(vecX, Q.n_rows, Q.n_cols); + return true; + } + else + { + X.reset(); + return false; + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/blas_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/blas_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,75 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#ifdef ARMA_USE_BLAS + + +#if !defined(ARMA_BLAS_CAPITALS) + + #define arma_sdot sdot + #define arma_ddot ddot + + #define arma_sgemv sgemv + #define arma_dgemv dgemv + #define arma_cgemv cgemv + #define arma_zgemv zgemv + + #define arma_sgemm sgemm + #define arma_dgemm dgemm + #define arma_cgemm cgemm + #define arma_zgemm zgemm + +#else + + #define arma_sdot SDOT + #define arma_ddot DDOT + + #define arma_sgemv SGEMV + #define arma_dgemv DGEMV + #define arma_cgemv CGEMV + #define arma_zgemv ZGEMV + + #define arma_sgemm SGEMM + #define arma_dgemm DGEMM + #define arma_cgemm CGEMM + #define arma_zgemm ZGEMM + +#endif + + + +extern "C" + { + float arma_fortran(arma_sdot)(blas_int* n, const float* x, blas_int* incx, const float* y, blas_int* incy); + double arma_fortran(arma_ddot)(blas_int* n, const double* x, blas_int* incx, const double* y, blas_int* incy); + + void arma_fortran(arma_sgemv)(const char* transA, const blas_int* m, const blas_int* n, const float* alpha, const float* A, const blas_int* ldA, const float* x, const blas_int* incx, const float* beta, float* y, const blas_int* incy); + void arma_fortran(arma_dgemv)(const char* transA, const blas_int* m, const blas_int* n, const double* alpha, const double* A, const blas_int* ldA, const double* x, const blas_int* incx, const double* beta, double* y, const blas_int* incy); + void arma_fortran(arma_cgemv)(const char* transA, const blas_int* m, const blas_int* n, const void* alpha, const void* A, const blas_int* ldA, const void* x, const blas_int* incx, const void* beta, void* y, const blas_int* incy); + void arma_fortran(arma_zgemv)(const char* transA, const blas_int* m, const blas_int* n, const void* alpha, const void* A, const blas_int* ldA, const void* x, const blas_int* incx, const void* beta, void* y, const blas_int* incy); + + void arma_fortran(arma_sgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const float* alpha, const float* A, const blas_int* ldA, const float* B, const blas_int* ldB, const float* beta, float* C, const blas_int* ldC); + void arma_fortran(arma_dgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const double* alpha, const double* A, const blas_int* ldA, const double* B, const blas_int* ldB, const double* beta, double* C, const blas_int* ldC); + void arma_fortran(arma_cgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const void* alpha, const void* A, const blas_int* ldA, const void* B, const blas_int* ldB, const void* beta, void* C, const blas_int* ldC); + void arma_fortran(arma_zgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const void* alpha, const void* A, const blas_int* ldA, const void* B, const blas_int* ldB, const void* beta, void* C, const blas_int* ldC); + + // void arma_fortran(arma_dswap)(const blas_int* n, double* x, const blas_int* incx, double* y, const blas_int* incy); + // void arma_fortran(arma_dscal)(const blas_int* n, const double* alpha, double* x, const blas_int* incx); + // void arma_fortran(arma_dcopy)(const blas_int* n, const double* x, const blas_int* incx, double* y, const blas_int* incy); + // void arma_fortran(arma_daxpy)(const blas_int* n, const double* alpha, const double* x, const blas_int* incx, double* y, const blas_int* incy); + // void arma_fortran(arma_dger )(const blas_int* m, const blas_int* n, const double* alpha, const double* x, const blas_int* incx, const double* y, const blas_int* incy, double* A, const blas_int* ldA); + } + + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/blas_wrapper.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/blas_wrapper.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,134 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#ifdef ARMA_USE_BLAS + + +//! \namespace blas namespace for BLAS functions +namespace blas + { + + + template + inline + eT + dot(const uword n_elem, const eT* x, const eT* y) + { + arma_ignore(n_elem); + arma_ignore(x); + arma_ignore(y); + + return eT(0); + } + + + + template<> + inline + float + dot(const uword n_elem, const float* x, const float* y) + { + blas_int n = blas_int(n_elem); + blas_int inc = blas_int(1); + + return arma_fortran(arma_sdot)(&n, x, &inc, y, &inc); + } + + + + template<> + inline + double + dot(const uword n_elem, const double* x, const double* y) + { + blas_int n = blas_int(n_elem); + blas_int inc = blas_int(1); + + return arma_fortran(arma_ddot)(&n, x, &inc, y, &inc); + } + + + + template + inline + void + gemv(const char* transA, const blas_int* m, const blas_int* n, const eT* alpha, const eT* A, const blas_int* ldA, const eT* x, const blas_int* incx, const eT* beta, eT* y, const blas_int* incy) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); + } + + } + + + + template + inline + void + gemm(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const eT* alpha, const eT* A, const blas_int* ldA, const eT* B, const blas_int* ldB, const eT* beta, eT* C, const blas_int* ldC) + { + arma_type_check((is_supported_blas_type::value == false)); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); + } + + } + + } + + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/cmath_wrap.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/cmath_wrap.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,344 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup cmath_wrap +//! @{ + + + +// +// wrappers for isfinite +// + + + +template +arma_inline +bool +arma_isfinite(eT val) + { + arma_ignore(val); + + return true; + } + + + +template<> +arma_inline +bool +arma_isfinite(float x) + { + #if defined(ARMA_HAVE_STD_ISFINITE) + { + return (std::isfinite(x) != 0); + } + #else + { + const bool x_is_inf = ( (x == x) && ((x - x) != float(0)) ); + const bool x_is_nan = (x != x); + + return ( (x_is_inf == false) && (x_is_nan == false) ); + } + #endif + } + + + +template<> +arma_inline +bool +arma_isfinite(double x) + { + #if defined(ARMA_HAVE_STD_ISFINITE) + { + return (std::isfinite(x) != 0); + } + #else + { + const bool x_is_inf = ( (x == x) && ((x - x) != double(0)) ); + const bool x_is_nan = (x != x); + + return ( (x_is_inf == false) && (x_is_nan == false) ); + } + #endif + } + + + +template +arma_inline +bool +arma_isfinite(const std::complex& x) + { + if( (arma_isfinite(x.real()) == false) || (arma_isfinite(x.imag()) == false) ) + { + return false; + } + else + { + return true; + } + } + + + +// +// wrappers for trigonometric functions +// + + + +// Wherever possible, try to use TR1 versions of the functions below, +// otherwise fall back to Boost Math. +// +// complex acos +// complex asin +// complex atan +// +// real acosh +// real asinh +// real atanh +// +// complex acosh +// complex asinh +// complex atanh +// +// +// If TR1 not present and Boost math not present, +// we have our own rudimentary versions of: +// +// real acosh +// real asinh +// real atanh + + + +#if defined(ARMA_USE_BOOST) + #define arma_boost_wrap(trig_fn, val) ( (boost::math::trig_fn)(val) ) +#else + #define arma_boost_wrap(trig_fn, val) ( arma_stop( #trig_fn "(): need Boost libraries" ), val ) +#endif + + +template +arma_inline +std::complex +arma_acos(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::acos(x); + } + #else + { + return arma_boost_wrap(acos, x); + } + #endif + } + + + +template +arma_inline +std::complex +arma_asin(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::asin(x); + } + #else + { + return arma_boost_wrap(asin, x); + } + #endif + } + + + +template +arma_inline +std::complex +arma_atan(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::atan(x); + } + #else + { + return arma_boost_wrap(atan, x); + } + #endif + } + + + +template +arma_inline +eT +arma_acosh(const eT x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::acosh(x); + } + #elif defined(ARMA_USE_BOOST) + { + return boost::math::acosh(x); + } + #else + { + if(x >= eT(1)) + { + // http://functions.wolfram.com/ElementaryFunctions/ArcCosh/02/ + return std::log( x + std::sqrt(x*x - eT(1)) ); + } + else + { + if(std::numeric_limits::has_quiet_NaN == true) + { + return -(std::numeric_limits::quiet_NaN()); + } + else + { + return eT(0); + } + } + } + #endif + } + + + +template +arma_inline +eT +arma_asinh(const eT x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::asinh(x); + } + #elif defined(ARMA_USE_BOOST) + { + return boost::math::asinh(x); + } + #else + { + // http://functions.wolfram.com/ElementaryFunctions/ArcSinh/02/ + return std::log( x + std::sqrt(x*x + eT(1)) ); + } + #endif + } + + + +template +arma_inline +eT +arma_atanh(const eT x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::atanh(x); + } + #elif defined(ARMA_USE_BOOST) + { + return boost::math::atanh(x); + } + #else + { + if( (x >= eT(-1)) && (x <= eT(+1)) ) + { + // http://functions.wolfram.com/ElementaryFunctions/ArcTanh/02/ + return std::log( ( eT(1)+x ) / ( eT(1)-x ) ) / eT(2); + } + else + { + if(std::numeric_limits::has_quiet_NaN == true) + { + return -(std::numeric_limits::quiet_NaN()); + } + else + { + return eT(0); + } + } + } + #endif + } + + + +template +arma_inline +std::complex +arma_acosh(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::acosh(x); + } + #else + { + return arma_boost_wrap(acosh, x); + } + #endif + } + + + +template +arma_inline +std::complex +arma_asinh(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::asinh(x); + } + #else + { + return arma_boost_wrap(asinh, x); + } + #endif + } + + + +template +arma_inline +std::complex +arma_atanh(const std::complex& x) + { + #if defined(ARMA_HAVE_STD_TR1) + { + return std::tr1::atanh(x); + } + #else + { + return arma_boost_wrap(atanh, x); + } + #endif + } + + + +#undef arma_boost_wrap + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/compiler_setup.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/compiler_setup.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,160 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#define arma_hot +#define arma_cold +#define arma_pure +#define arma_const +#define arma_inline inline +#define arma_aligned +#define arma_warn_unused +#define arma_deprecated +#define arma_ignore(variable) ((void)(variable)) + + +#if defined(ARMA_BLAS_UNDERSCORE) + #define arma_fortran2_noprefix(function) function##_ + #define arma_fortran2_prefix(function) wrapper_##function##_ +#else + #define arma_fortran2_prefix(function) wrapper_##function + #define arma_fortran2_noprefix(function) function +#endif + +#if defined(ARMA_USE_WRAPPER) + #define arma_fortran(function) arma_fortran2_prefix(function) + #define arma_atlas(function) wrapper_##function +#else + #define arma_fortran(function) arma_fortran2_noprefix(function) + #define arma_atlas(function) function +#endif + +#define arma_fortran_prefix(function) arma_fortran2_prefix(function) +#define arma_fortran_noprefix(function) arma_fortran2_noprefix(function) + + +#define ARMA_INCFILE_WRAP(x) + + +#if defined(__INTEL_COMPILER) + + #if (__INTEL_COMPILER < 1000) + #error "*** Need a newer compiler ***" + #endif + + #define ARMA_GOOD_COMPILER + #undef ARMA_HAVE_STD_TR1 + + #if (__INTEL_COMPILER <= 1110) + #undef ARMA_HAVE_STD_ISFINITE + #endif + +#elif defined(__GNUG__) + + #if (__GNUC__ < 4) + #error "*** Need a newer compiler ***" + #endif + + #define ARMA_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) + + #define ARMA_GOOD_COMPILER + #undef ARMA_HAVE_STD_TR1 + + #undef arma_pure + #undef arma_const + #undef arma_inline + #undef arma_aligned + #undef arma_warn_unused + #undef arma_deprecated + + #define arma_pure __attribute__((pure)) + #define arma_const __attribute__((const)) + #define arma_inline inline __attribute__((always_inline)) + #define arma_aligned __attribute__((aligned)) + #define arma_warn_unused __attribute__((warn_unused_result)) + #define arma_deprecated __attribute__((deprecated)) + + #if (ARMA_GCC_VERSION >= 40200) + #if defined(_GLIBCXX_USE_C99_MATH_TR1) && defined(_GLIBCXX_USE_C99_COMPLEX_TR1) + #define ARMA_HAVE_STD_TR1 + #endif + #endif + + #if defined(__GXX_EXPERIMENTAL_CXX0X__) + #undef ARMA_HAVE_STD_TR1 + + #if !defined(ARMA_USE_CXX11) + #define ARMA_USE_CXX11 + #endif + #endif + + #if defined(__clang__) + #undef ARMA_HAVE_STD_TR1 + #endif + + #if (ARMA_GCC_VERSION >= 40300) + #undef arma_hot + #undef arma_cold + + #define arma_hot __attribute__((hot)) + #define arma_cold __attribute__((cold)) + #endif + + #undef ARMA_GCC_VERSION + +#endif + + +#if defined(_MSC_VER) + + #if (_MSC_VER < 1500) + #error "*** Need a newer compiler ***" + #endif + + #undef ARMA_GOOD_COMPILER + #undef ARMA_HAVE_STD_ISFINITE + #undef ARMA_HAVE_STD_SNPRINTF + #undef ARMA_HAVE_LOG1P + #undef ARMA_HAVE_STD_ISINF + #undef ARMA_HAVE_STD_ISNAN + #undef ARMA_HAVE_STD_TR1 + + #undef arma_inline + #define arma_inline inline __forceinline + + // #if (_MSC_VER >= 1400) + // #undef arma_aligned + // #define arma_aligned __declspec(align(16)) + // #endif + +#endif + + +#if defined(__CUDACC__) + #undef ARMA_HAVE_STD_ISFINITE + #undef ARMA_HAVE_STD_SNPRINTF + #undef ARMA_HAVE_LOG1P + #undef ARMA_HAVE_STD_ISINF + #undef ARMA_HAVE_STD_ISNAN + #undef ARMA_HAVE_STD_TR1 +#endif + + +#if defined(__SUNPRO_CC) + #undef ARMA_HAVE_STD_ISFINITE + #undef ARMA_HAVE_STD_SNPRINTF + #undef ARMA_HAVE_LOG1P + #undef ARMA_HAVE_STD_ISINF + #undef ARMA_HAVE_STD_ISNAN + #undef ARMA_HAVE_STD_TR1 +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/config.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/config.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,109 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +// #define ARMA_64BIT_WORD +//// Uncomment the above line if you require matrices/vectors capable of holding more than 4 billion elements. +//// Your machine and compiler must have support for 64 bit integers (eg. via "long" or "long long") + +// #define ARMA_USE_CXX11 +//// Uncomment the above line if you have a C++ compiler that supports the C++11 standard +//// This will enable additional features, such as use of initialiser lists + +#if !defined(ARMA_USE_LAPACK) +#define ARMA_USE_LAPACK +//// Uncomment the above line if you have LAPACK or a fast replacement for LAPACK, +//// such as Intel's MKL, AMD's ACML, or the Accelerate framework. +//// LAPACK is required for matrix decompositions (eg. SVD) and matrix inverse. +#endif + +#if !defined(ARMA_USE_BLAS) +#define ARMA_USE_BLAS +//// Uncomment the above line if you have BLAS or a fast replacement for BLAS, +//// such as GotoBLAS, Intel's MKL, AMD's ACML, or the Accelerate framework. +//// BLAS is used for matrix multiplication. +//// Without BLAS, matrix multiplication will still work, but might be slower. +#endif + +// #define ARMA_BLAS_LONG +//// Uncomment the above line if your BLAS and LAPACK libraries use "long" instead of "int" + +// #define ARMA_BLAS_LONG_LONG +//// Uncomment the above line if your BLAS and LAPACK libraries use "long long" instead of "int" + +#define ARMA_BLAS_UNDERSCORE +//// Uncomment the above line if your BLAS and LAPACK libraries have function names with a trailing underscore. +//// Conversely, comment it out if the function names don't have a trailing underscore. + +// #define ARMA_BLAS_CAPITALS +//// Uncomment the above line if your BLAS and LAPACK libraries have capitalised function names (eg. ACML on 64-bit Windows) + +#if !defined(ARMA_MAT_PREALLOC) + #define ARMA_MAT_PREALLOC 16 +#endif +//// This is the number of preallocated elements used by matrices and vectors; +//// it must be an integer that is at least 1. +//// If you mainly use lots of very small vectors (eg. <= 4 elements), +//// change the number to the size of your vectors. + +// #define ARMA_USE_TBB_ALLOC +//// Uncomment the above line if you want to use Intel TBB scalable_malloc() and scalable_free() instead of standard new[] and delete[] + +// #define ARMA_USE_ATLAS +// #define ARMA_ATLAS_INCLUDE_DIR /usr/include/ +//// If you're using ATLAS and the compiler can't find cblas.h and/or clapack.h +//// uncomment the above define and specify the appropriate include directory. +//// Make sure the directory has a trailing / + +// #define ARMA_USE_BOOST +// #define ARMA_USE_BOOST_DATE +// #define ARMA_USE_WRAPPER + +#if !defined(ARMA_DEFAULT_OSTREAM) + #define ARMA_DEFAULT_OSTREAM std::cout +#endif + +#define ARMA_PRINT_LOGIC_ERRORS +#define ARMA_PRINT_RUNTIME_ERRORS + +// #define ARMA_HAVE_STD_ISFINITE +// #define ARMA_HAVE_STD_ISINF +// #define ARMA_HAVE_STD_ISNAN +// #define ARMA_HAVE_STD_SNPRINTF + +// #define ARMA_HAVE_LOG1P +// #define ARMA_HAVE_GETTIMEOFDAY + +// #define ARMA_EXTRA_DEBUG +// #define ARMA_NO_DEBUG + +#if defined(ARMA_DONT_USE_ATLAS) + #undef ARMA_USE_ATLAS + #undef ARMA_ATLAS_INCLUDE_DIR +#endif + +#if defined(ARMA_DONT_USE_LAPACK) + #undef ARMA_USE_LAPACK +#endif + +#if defined(ARMA_DONT_USE_BLAS) + #undef ARMA_USE_BLAS +#endif + +#if defined(ARMA_DONT_PRINT_LOGIC_ERRORS) + #undef ARMA_PRINT_LOGIC_ERRORS +#endif + +#if defined(ARMA_DONT_PRINT_RUNTIME_ERRORS) + #undef ARMA_PRINT_RUNTIME_ERRORS +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/config.hpp.cmake --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/config.hpp.cmake Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,109 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +// #define ARMA_64BIT_WORD +//// Uncomment the above line if you require matrices/vectors capable of holding more than 4 billion elements. +//// Your machine and compiler must have support for 64 bit integers (eg. via "long" or "long long") + +// #define ARMA_USE_CXX11 +//// Uncomment the above line if you have a C++ compiler that supports the C++11 standard +//// This will enable additional features, such as use of initialiser lists + +#if !defined(ARMA_USE_LAPACK) +#cmakedefine ARMA_USE_LAPACK +//// Uncomment the above line if you have LAPACK or a fast replacement for LAPACK, +//// such as Intel's MKL, AMD's ACML, or the Accelerate framework. +//// LAPACK is required for matrix decompositions (eg. SVD) and matrix inverse. +#endif + +#if !defined(ARMA_USE_BLAS) +#cmakedefine ARMA_USE_BLAS +//// Uncomment the above line if you have BLAS or a fast replacement for BLAS, +//// such as GotoBLAS, Intel's MKL, AMD's ACML, or the Accelerate framework. +//// BLAS is used for matrix multiplication. +//// Without BLAS, matrix multiplication will still work, but might be slower. +#endif + +// #define ARMA_BLAS_LONG +//// Uncomment the above line if your BLAS and LAPACK libraries use "long" instead of "int" + +// #define ARMA_BLAS_LONG_LONG +//// Uncomment the above line if your BLAS and LAPACK libraries use "long long" instead of "int" + +#define ARMA_BLAS_UNDERSCORE +//// Uncomment the above line if your BLAS and LAPACK libraries have function names with a trailing underscore. +//// Conversely, comment it out if the function names don't have a trailing underscore. + +// #define ARMA_BLAS_CAPITALS +//// Uncomment the above line if your BLAS and LAPACK libraries have capitalised function names (eg. ACML on 64-bit Windows) + +#if !defined(ARMA_MAT_PREALLOC) + #define ARMA_MAT_PREALLOC 16 +#endif +//// This is the number of preallocated elements used by matrices and vectors; +//// it must be an integer that is at least 1. +//// If you mainly use lots of very small vectors (eg. <= 4 elements), +//// change the number to the size of your vectors. + +// #define ARMA_USE_TBB_ALLOC +//// Uncomment the above line if you want to use Intel TBB scalable_malloc() and scalable_free() instead of standard new[] and delete[] + +#cmakedefine ARMA_USE_ATLAS +#define ARMA_ATLAS_INCLUDE_DIR ${ARMA_ATLAS_INCLUDE_DIR}/ +//// If you're using ATLAS and the compiler can't find cblas.h and/or clapack.h +//// uncomment the above define and specify the appropriate include directory. +//// Make sure the directory has a trailing / + +#cmakedefine ARMA_USE_BOOST +#cmakedefine ARMA_USE_BOOST_DATE +#cmakedefine ARMA_USE_WRAPPER + +#if !defined(ARMA_DEFAULT_OSTREAM) + #define ARMA_DEFAULT_OSTREAM std::cout +#endif + +#define ARMA_PRINT_LOGIC_ERRORS +#define ARMA_PRINT_RUNTIME_ERRORS + +#cmakedefine ARMA_HAVE_STD_ISFINITE +#cmakedefine ARMA_HAVE_STD_ISINF +#cmakedefine ARMA_HAVE_STD_ISNAN +#cmakedefine ARMA_HAVE_STD_SNPRINTF + +#cmakedefine ARMA_HAVE_LOG1P +#cmakedefine ARMA_HAVE_GETTIMEOFDAY + +// #define ARMA_EXTRA_DEBUG +// #define ARMA_NO_DEBUG + +#if defined(ARMA_DONT_USE_ATLAS) + #undef ARMA_USE_ATLAS + #undef ARMA_ATLAS_INCLUDE_DIR +#endif + +#if defined(ARMA_DONT_USE_LAPACK) + #undef ARMA_USE_LAPACK +#endif + +#if defined(ARMA_DONT_USE_BLAS) + #undef ARMA_USE_BLAS +#endif + +#if defined(ARMA_DONT_PRINT_LOGIC_ERRORS) + #undef ARMA_PRINT_LOGIC_ERRORS +#endif + +#if defined(ARMA_DONT_PRINT_RUNTIME_ERRORS) + #undef ARMA_PRINT_RUNTIME_ERRORS +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/constants.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/constants.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,332 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup constants +//! @{ + + +namespace priv + { + class Math_helper + { + public: + + template + static + typename arma_float_only::result + nan(typename arma_float_only::result* junk = 0) + { + arma_ignore(junk); + + if(std::numeric_limits::has_quiet_NaN == true) + { + return std::numeric_limits::quiet_NaN(); + } + else + { + return eT(0); + } + } + + + template + static + typename arma_cx_only::result + nan(typename arma_cx_only::result* junk = 0) + { + arma_ignore(junk); + + typedef typename get_pod_type::result T; + + return eT( Math_helper::nan(), Math_helper::nan() ); + } + + + template + static + typename arma_integral_only::result + nan(typename arma_integral_only::result* junk = 0) + { + arma_ignore(junk); + + return eT(0); + } + + + template + static + typename arma_float_only::result + inf(typename arma_float_only::result* junk = 0) + { + arma_ignore(junk); + + if(std::numeric_limits::has_infinity == true) + { + return std::numeric_limits::infinity(); + } + else + { + return std::numeric_limits::max(); + } + } + + + template + static + typename arma_cx_only::result + inf(typename arma_cx_only::result* junk = 0) + { + arma_ignore(junk); + + typedef typename get_pod_type::result T; + + return eT( Math_helper::inf(), Math_helper::inf() ); + } + + + template + static + typename arma_integral_only::result + inf(typename arma_integral_only::result* junk = 0) + { + arma_ignore(junk); + + return std::numeric_limits::max(); + } + + }; + } + + + +template +class Math + { + public: + + // the long lengths of the constants are for future support of "long double" + // and any smart compiler that does high-precision computation at compile-time + + //! ratio of any circle's circumference to its diameter + static eT pi() { return eT(3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679); } + + //! base of the natural logarithm + static eT e() { return eT(2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274); } + + //! Euler's constant, aka Euler-Mascheroni constant + static eT euler() { return eT(0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495); } + + //! golden ratio + static eT gratio() { return eT(1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374); } + + //! square root of 2 + static eT sqrt2() { return eT(1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727); } + + //! the difference between 1 and the least value greater than 1 that is representable + static eT eps() { return std::numeric_limits::epsilon(); } + + //! log of the minimum representable value + static eT log_min() { static const eT out = std::log(std::numeric_limits::min()); return out; } + + //! log of the maximum representable value + static eT log_max() { static const eT out = std::log(std::numeric_limits::max()); return out; } + + //! "not a number" + static eT nan() { return priv::Math_helper::nan(); } + + //! infinity + static eT inf() { return priv::Math_helper::inf(); } + }; + + + +//! Physical constants taken from NIST and WolframAlpha on 2009-06-23 +//! http://physics.nist.gov/cuu/Constants +//! http://www.wolframalpha.com +//! See also http://en.wikipedia.org/wiki/Physical_constant +template +class Phy + { + public: + + //! atomic mass constant (in kg) + static eT m_u() { return eT(1.660538782e-27); } + + //! Avogadro constant + static eT N_A() { return eT(6.02214179e23); } + + //! Boltzmann constant (in joules per kelvin) + static eT k() { return eT(1.3806504e-23); } + + //! Boltzmann constant (in eV/K) + static eT k_evk() { return eT(8.617343e-5); } + + //! Bohr radius (in meters) + static eT a_0() { return eT(0.52917720859e-10); } + + //! Bohr magneton + static eT mu_B() { return eT(927.400915e-26); } + + //! characteristic impedance of vacuum (in ohms) + static eT Z_0() { return eT(3.76730313461771e-2); } + + //! conductance quantum (in siemens) + static eT G_0() { return eT(7.7480917004e-5); } + + //! Coulomb's constant (in meters per farad) + static eT k_e() { return eT(8.9875517873681764e9); } + + //! electric constant (in farads per meter) + static eT eps_0() { return eT(8.85418781762039e-12); } + + //! electron mass (in kg) + static eT m_e() { return eT(9.10938215e-31); } + + //! electron volt (in joules) + static eT eV() { return eT(1.602176487e-19); } + + //! elementary charge (in coulombs) + static eT e() { return eT(1.602176487e-19); } + + //! Faraday constant (in coulombs) + static eT F() { return eT(96485.3399); } + + //! fine-structure constant + static eT alpha() { return eT(7.2973525376e-3); } + + //! inverse fine-structure constant + static eT alpha_inv() { return eT(137.035999679); } + + //! Josephson constant + static eT K_J() { return eT(483597.891e9); } + + //! magnetic constant (in henries per meter) + static eT mu_0() { return eT(1.25663706143592e-06); } + + //! magnetic flux quantum (in webers) + static eT phi_0() { return eT(2.067833667e-15); } + + //! molar gas constant (in joules per mole kelvin) + static eT R() { return eT(8.314472); } + + //! Newtonian constant of gravitation (in newton square meters per kilogram squared) + static eT G() { return eT(6.67428e-11); } + + //! Planck constant (in joule seconds) + static eT h() { return eT(6.62606896e-34); } + + //! Planck constant over 2 pi, aka reduced Planck constant (in joule seconds) + static eT h_bar() { return eT(1.054571628e-34); } + + //! proton mass (in kg) + static eT m_p() { return eT(1.672621637e-27); } + + //! Rydberg constant (in reciprocal meters) + static eT R_inf() { return eT(10973731.568527); } + + //! speed of light in vacuum (in meters per second) + static eT c_0() { return eT(299792458.0); } + + //! Stefan-Boltzmann constant + static eT sigma() { return eT(5.670400e-8); } + + //! von Klitzing constant (in ohms) + static eT R_k() { return eT(25812.807557); } + + //! Wien wavelength displacement law constant + static eT b() { return eT(2.8977685e-3); } + }; + + + +typedef Math fmath; +typedef Math math; + +typedef Phy fphy; +typedef Phy phy; + + + +namespace priv + { + + template + static + arma_inline + arma_hot + typename arma_float_only::result + most_neg(typename arma_float_only::result* junk = 0) + { + arma_ignore(junk); + + if(std::numeric_limits::has_infinity == true) + { + return -(std::numeric_limits::infinity()); + } + else + { + return -(std::numeric_limits::max()); + } + } + + + template + static + arma_inline + arma_hot + typename arma_integral_only::result + most_neg(typename arma_integral_only::result* junk = 0) + { + arma_ignore(junk); + + return std::numeric_limits::min(); + } + + + template + static + arma_inline + arma_hot + typename arma_float_only::result + most_pos(typename arma_float_only::result* junk = 0) + { + arma_ignore(junk); + + if(std::numeric_limits::has_infinity == true) + { + return std::numeric_limits::infinity(); + } + else + { + return std::numeric_limits::max(); + } + } + + + template + static + arma_inline + arma_hot + typename arma_integral_only::result + most_pos(typename arma_integral_only::result* junk = 0) + { + arma_ignore(junk); + + return std::numeric_limits::max(); + } + + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/debug.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/debug.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1183 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup debug +//! @{ + + + +template +inline +std::ostream& +arma_stream_err1(std::ostream* user_stream) + { + static std::ostream* stream_err1 = &(ARMA_DEFAULT_OSTREAM); + + if(user_stream != NULL) + { + stream_err1 = user_stream; + } + + return *stream_err1; + } + + + +template +inline +std::ostream& +arma_stream_err2(std::ostream* user_stream) + { + static std::ostream* stream_err2 = &(ARMA_DEFAULT_OSTREAM); + + if(user_stream != NULL) + { + stream_err2 = user_stream; + } + + return *stream_err2; + } + + + +inline +void +set_stream_err1(std::ostream& user_stream) + { + arma_stream_err1(&user_stream); + } + + + +inline +void +set_stream_err2(std::ostream& user_stream) + { + arma_stream_err2(&user_stream); + } + + + +inline +std::ostream& +get_stream_err1() + { + return arma_stream_err1(NULL); + } + + + +inline +std::ostream& +get_stream_err2() + { + return arma_stream_err2(NULL); + } + + + +// +// arma_stop + +//! print a message to get_stream_err1() and/or throw a logic_error exception +template +inline +void +arma_cold +arma_stop(const T1& x) + { + #if defined(ARMA_PRINT_LOGIC_ERRORS) + { + std::ostream& out = get_stream_err1(); + + out.flush(); + + out << '\n'; + out << "error: " << x << '\n'; + out << '\n'; + out.flush(); + } + #else + { + arma_ignore(x); + } + #endif + + throw std::logic_error(""); + } + + + +template +inline +void +arma_cold +arma_stop_bad_alloc(const T1& x) + { + std::ostream& out = get_stream_err1(); + + out.flush(); + + out << '\n'; + out << "error: " << x << '\n'; + out << '\n'; + out.flush(); + + throw std::bad_alloc(); + } + + + +// +// arma_bad + +//! print a message to get_stream_err2() and/or throw a run-time error exception +template +inline +void +arma_cold +arma_bad(const T1& x, const bool hurl = true) + { + #if defined(ARMA_PRINT_RUNTIME_ERRORS) + { + std::ostream& out = get_stream_err2(); + + out.flush(); + + out << '\n'; + out << "error: " << x << '\n'; + out << '\n'; + out.flush(); + } + #else + { + arma_ignore(x); + } + #endif + + if(hurl == true) + { + throw std::runtime_error(""); + } + } + + + +// +// arma_print + + +inline +void +arma_cold +arma_print() + { + get_stream_err1() << std::endl; + } + + +template +inline +void +arma_cold +arma_print(const T1& x) + { + get_stream_err1() << x << std::endl; + } + + + +template +inline +void +arma_cold +arma_print(const T1& x, const T2& y) + { + get_stream_err1() << x << y << std::endl; + } + + + +template +inline +void +arma_cold +arma_print(const T1& x, const T2& y, const T3& z) + { + get_stream_err1() << x << y << z << std::endl; + } + + + + + + +// +// arma_sigprint + +//! print a message the the log stream with a preceding @ character. +//! by default the log stream is cout. +//! used for printing the signature of a function +//! (see the arma_extra_debug_sigprint macro) +inline +void +arma_sigprint(const char* x) + { + get_stream_err1() << "@ " << x; + } + + + +// +// arma_bktprint + + +inline +void +arma_bktprint() + { + get_stream_err1() << std::endl; + } + + +template +inline +void +arma_bktprint(const T1& x) + { + get_stream_err1() << " [" << x << ']' << std::endl; + } + + + +template +inline +void +arma_bktprint(const T1& x, const T2& y) + { + get_stream_err1() << " [" << x << y << ']' << std::endl; + } + + + + + + +// +// arma_thisprint + +inline +void +arma_thisprint(const void* this_ptr) + { + get_stream_err1() << " [this = " << this_ptr << ']' << std::endl; + } + + + +// +// arma_warn + + +//! print a message to the warn stream +template +inline +void +arma_cold +arma_warn(const bool state, const T1& x) + { + if(state==true) + { + get_stream_err2() << x << std::endl; + } + } + + +template +inline +void +arma_cold +arma_warn(const bool state, const T1& x, const T2& y) + { + if(state==true) + { + get_stream_err2() << x << y << std::endl; + } + } + + +template +inline +void +arma_cold +arma_warn(const bool state, const T1& x, const T2& y, const T3& z) + { + if(state==true) + { + get_stream_err2() << x << y << z << std::endl; + } + } + + + +// +// arma_check + +//! if state is true, abort program +template +inline +void +arma_hot +arma_check(const bool state, const T1& x) + { + if(state==true) + { + arma_stop(arma_boost::str_wrapper(x)); + } + } + + +template +inline +void +arma_hot +arma_check(const bool state, const T1& x, const T2& y) + { + if(state==true) + { + arma_stop( std::string(x) + std::string(y) ); + } + } + + +template +inline +void +arma_hot +arma_check_bad_alloc(const bool state, const T1& x) + { + if(state==true) + { + arma_stop_bad_alloc(x); + } + } + + + +// +// arma_set_error + + +arma_inline +void +arma_hot +arma_set_error(bool& err_state, char*& err_msg, const bool expression, const char* message) + { + if(expression == true) + { + err_state = true; + err_msg = const_cast(message); + } + } + + + + +// +// functions for generating strings indicating size errors + +inline +std::string +arma_cold +arma_incompat_size_string(const uword A_n_rows, const uword A_n_cols, const uword B_n_rows, const uword B_n_cols, const char* x) + { + std::stringstream tmp; + + tmp << x << ": incompatible matrix dimensions: " << A_n_rows << 'x' << A_n_cols << " and " << B_n_rows << 'x' << B_n_cols; + + return tmp.str(); + } + + + +inline +arma_cold +std::string +arma_incompat_size_string(const uword A_n_rows, const uword A_n_cols, const uword A_n_slices, const uword B_n_rows, const uword B_n_cols, const uword B_n_slices, const char* x) + { + std::stringstream tmp; + + tmp << x << ": incompatible cube dimensions: " << A_n_rows << 'x' << A_n_cols << 'x' << A_n_slices << " and " << B_n_rows << 'x' << B_n_cols << 'x' << B_n_slices; + + return tmp.str(); + } + + + +template +inline +arma_cold +std::string +arma_incompat_size_string(const subview_cube& Q, const Mat& A, const char* x) + { + std::stringstream tmp; + + tmp << x + << ": interpreting matrix as cube with dimenensions: " + << A.n_rows << 'x' << A.n_cols << 'x' << 1 + << " or " + << A.n_rows << 'x' << 1 << 'x' << A.n_cols + << " or " + << 1 << 'x' << A.n_rows << 'x' << A.n_cols + << " is incompatible with cube dimensions: " + << Q.n_rows << 'x' << Q.n_cols << 'x' << Q.n_slices; + + return tmp.str(); + } + + + +// +// functions for checking whether two matrices have the same dimensions + + + +inline +void +arma_hot +arma_assert_same_size(const uword A_n_rows, const uword A_n_cols, const uword B_n_rows, const uword B_n_cols, const char* x) + { + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +//! stop if given matrices have different sizes +template +inline +void +arma_hot +arma_assert_same_size(const Mat& A, const Mat& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +//! stop if given proxies have different sizes +template +inline +void +arma_hot +arma_assert_same_size(const Proxy& A, const Proxy& B, const char* x) + { + const uword A_n_rows = A.get_n_rows(); + const uword A_n_cols = A.get_n_cols(); + + const uword B_n_rows = B.get_n_rows(); + const uword B_n_cols = B.get_n_cols(); + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview& A, const subview& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Mat& A, const subview& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview& A, const Mat& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Mat& A, const Proxy& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.get_n_rows(); + const uword B_n_cols = B.get_n_cols(); + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Proxy& A, const Mat& B, const char* x) + { + const uword A_n_rows = A.get_n_rows(); + const uword A_n_cols = A.get_n_cols(); + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Proxy& A, const subview& B, const char* x) + { + const uword A_n_rows = A.get_n_rows(); + const uword A_n_cols = A.get_n_cols(); + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview& A, const Proxy& B, const char* x) + { + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.get_n_rows(); + const uword B_n_cols = B.get_n_cols(); + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +// +// functions for checking whether two cubes have the same dimensions + + + +inline +void +arma_hot +arma_assert_same_size(const uword A_n_rows, const uword A_n_cols, const uword A_n_slices, const uword B_n_rows, const uword B_n_cols, const uword B_n_slices, const char* x) + { + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) || (A_n_slices != B_n_slices) ) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, A_n_slices, B_n_rows, B_n_cols, B_n_slices, x) ); + } + } + + + +//! stop if given cubes have different sizes +template +inline +void +arma_hot +arma_assert_same_size(const Cube& A, const Cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != B.n_slices) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Cube& A, const subview_cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != B.n_slices) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview_cube& A, const Cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != B.n_slices) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview_cube& A, const subview_cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != B.n_slices)) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +//! stop if given cube proxies have different sizes +template +inline +void +arma_hot +arma_assert_same_size(const ProxyCube& A, const ProxyCube& B, const char* x) + { + const uword A_n_rows = A.get_n_rows(); + const uword A_n_cols = A.get_n_cols(); + const uword A_n_slices = A.get_n_slices(); + + const uword B_n_rows = B.get_n_rows(); + const uword B_n_cols = B.get_n_cols(); + const uword B_n_slices = B.get_n_slices(); + + if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) || (A_n_slices != B_n_slices)) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, A_n_slices, B_n_rows, B_n_cols, B_n_slices, x) ); + } + } + + + +// +// functions for checking whether a cube or subcube can be interpreted as a matrix (i.e. single slice) + + + +template +inline +void +arma_hot +arma_assert_same_size(const Cube& A, const Mat& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != 1) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, 1, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Mat& A, const Cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (1 != B.n_slices) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, 1, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const subview_cube& A, const Mat& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (A.n_slices != 1) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, A.n_slices, B.n_rows, B.n_cols, 1, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_same_size(const Mat& A, const subview_cube& B, const char* x) + { + if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (1 != B.n_slices) ) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, 1, B.n_rows, B.n_cols, B.n_slices, x) ); + } + } + + + +template +inline +void +arma_assert_cube_as_mat(const Mat& M, const T1& Q, const char* x, const bool check_compat_size) + { + const uword Q_n_rows = Q.n_rows; + const uword Q_n_cols = Q.n_cols; + const uword Q_n_slices = Q.n_slices; + + const uword M_vec_state = M.vec_state; + + if(M_vec_state == 0) + { + if( ( (Q_n_rows == 1) || (Q_n_cols == 1) || (Q_n_slices == 1) ) == false ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a matrix; one of the dimensions must be 1"; + + arma_stop( tmp.str() ); + } + } + else + { + if(Q_n_slices == 1) + { + if( (M_vec_state == 1) && (Q_n_cols != 1) ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a column vector"; + + arma_stop( tmp.str() ); + } + + if( (M_vec_state == 2) && (Q_n_rows != 1) ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a row vector"; + + arma_stop( tmp.str() ); + } + } + else + { + if( (Q_n_cols != 1) && (Q_n_rows != 1) ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a vector"; + + arma_stop( tmp.str() ); + } + } + } + + + if(check_compat_size == true) + { + const uword M_n_rows = M.n_rows; + const uword M_n_cols = M.n_cols; + + if(M_vec_state == 0) + { + if( + ( + ( (Q_n_rows == M_n_rows) && (Q_n_cols == M_n_cols) ) + || + ( (Q_n_rows == M_n_rows) && (Q_n_slices == M_n_cols) ) + || + ( (Q_n_cols == M_n_rows) && (Q_n_slices == M_n_cols) ) + ) + == false + ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimenensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a matrix with dimensions " + << M_n_rows << 'x' << M_n_cols; + + arma_stop( tmp.str() ); + } + } + else + { + if(Q_n_slices == 1) + { + if( (M_vec_state == 1) && (Q_n_rows != M_n_rows) ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a column vector with dimensions " + << M_n_rows << 'x' << M_n_cols; + + arma_stop( tmp.str() ); + } + + if( (M_vec_state == 2) && (Q_n_cols != M_n_cols) ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a row vector with dimensions " + << M_n_rows << 'x' << M_n_cols; + + arma_stop( tmp.str() ); + } + } + else + { + if( ( (M_n_cols == Q_n_slices) || (M_n_rows == Q_n_slices) ) == false ) + { + std::stringstream tmp; + + tmp << x + << ": can't interpret cube with dimensions " + << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices + << " as a vector with dimensions " + << M_n_rows << 'x' << M_n_cols; + + arma_stop( tmp.str() ); + } + } + } + } + } + + + +// +// functions for checking whether two matrices have dimensions that are compatible with the matrix multiply operation + + + +inline +void +arma_hot +arma_assert_mul_size(const uword A_n_rows, const uword A_n_cols, const uword B_n_rows, const uword B_n_cols, const char* x) + { + if(A_n_cols != B_n_rows) + { + arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); + } + } + + + +//! stop if given matrices are incompatible for multiplication +template +inline +void +arma_hot +arma_assert_mul_size(const Mat& A, const Mat& B, const char* x) + { + const uword A_n_cols = A.n_cols; + const uword B_n_rows = B.n_rows; + + if(A_n_cols != B_n_rows) + { + arma_stop( arma_incompat_size_string(A.n_rows, A_n_cols, B_n_rows, B.n_cols, x) ); + } + } + + + +//! stop if given matrices are incompatible for multiplication +template +inline +void +arma_hot +arma_assert_mul_size(const Mat& A, const Mat& B, const bool do_trans_A, const bool do_trans_B, const char* x) + { + const uword final_A_n_cols = (do_trans_A == false) ? A.n_cols : A.n_rows; + const uword final_B_n_rows = (do_trans_B == false) ? B.n_rows : B.n_cols; + + if(final_A_n_cols != final_B_n_rows) + { + const uword final_A_n_rows = (do_trans_A == false) ? A.n_rows : A.n_cols; + const uword final_B_n_cols = (do_trans_B == false) ? B.n_cols : B.n_rows; + + arma_stop( arma_incompat_size_string(final_A_n_rows, final_A_n_cols, final_B_n_rows, final_B_n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_mul_size(const Mat& A, const subview& B, const char* x) + { + if(A.n_cols != B.n_rows) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, B.n_rows, B.n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_mul_size(const subview& A, const Mat& B, const char* x) + { + if(A.n_cols != B.n_rows) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, B.n_rows, B.n_cols, x) ); + } + } + + + +template +inline +void +arma_hot +arma_assert_mul_size(const subview& A, const subview& B, const char* x) + { + if(A.n_cols != B.n_rows) + { + arma_stop( arma_incompat_size_string(A.n_rows, A.n_cols, B.n_rows, B.n_cols, x) ); + } + } + + + +// +// macros + + +#define ARMA_STRING1(x) #x +#define ARMA_STRING2(x) ARMA_STRING1(x) +#define ARMA_FILELINE __FILE__ ": " ARMA_STRING2(__LINE__) + + +#if defined (__GNUG__) + #define ARMA_FNSIG __PRETTY_FUNCTION__ +#elif defined (_MSC_VER) + #define ARMA_FNSIG __FUNCSIG__ +#elif defined (ARMA_USE_BOOST) + #define ARMA_FNSIG BOOST_CURRENT_FUNCTION +#else + #define ARMA_FNSIG "(unknown)" +#endif + + + +#if !defined(ARMA_NO_DEBUG) && !defined(NDEBUG) + + #define arma_debug_print arma_print + #define arma_debug_warn arma_warn + #define arma_debug_check arma_check + #define arma_debug_set_error arma_set_error + #define arma_debug_assert_same_size arma_assert_same_size + #define arma_debug_assert_mul_size arma_assert_mul_size + #define arma_debug_assert_cube_as_mat arma_assert_cube_as_mat + +#else + + #undef ARMA_EXTRA_DEBUG + + #define arma_debug_print true ? (void)0 : arma_print + #define arma_debug_warn true ? (void)0 : arma_warn + #define arma_debug_check true ? (void)0 : arma_check + #define arma_debug_set_error true ? (void)0 : arma_set_error + #define arma_debug_assert_same_size true ? (void)0 : arma_assert_same_size + #define arma_debug_assert_mul_size true ? (void)0 : arma_assert_mul_size + #define arma_debug_assert_cube_as_mat true ? (void)0 : arma_debug_assert_cube_as_mat + +#endif + + + +#if defined(ARMA_EXTRA_DEBUG) + + #define arma_extra_debug_sigprint arma_sigprint(ARMA_FNSIG); arma_bktprint + #define arma_extra_debug_sigprint_this arma_sigprint(ARMA_FNSIG); arma_thisprint + #define arma_extra_debug_print arma_print + #define arma_extra_debug_warn arma_warn + #define arma_extra_debug_check arma_check + +#else + + #define arma_extra_debug_sigprint true ? (void)0 : arma_bktprint + #define arma_extra_debug_sigprint_this true ? (void)0 : arma_thisprint + #define arma_extra_debug_print true ? (void)0 : arma_print + #define arma_extra_debug_warn true ? (void)0 : arma_warn + #define arma_extra_debug_check true ? (void)0 : arma_check + +#endif + + + + +#if defined(ARMA_EXTRA_DEBUG) + + namespace junk + { + class arma_first_extra_debug_message + { + public: + + inline + arma_cold + arma_first_extra_debug_message() + { + union + { + unsigned short a; + unsigned char b[sizeof(unsigned short)]; + } endian_test; + + endian_test.a = 1; + + const bool little_endian = (endian_test.b[0] == 1); + const char* nickname = ARMA_VERSION_NAME; + + std::ostream& out = get_stream_err1(); + + out << "@ ---" << '\n'; + out << "@ Armadillo " + << arma_version::major << '.' << arma_version::minor << '.' << arma_version::patch + << " (" << nickname << ")\n"; + + out << "@ arma_config::mat_prealloc = " << arma_config::mat_prealloc << " element(s)\n"; + out << "@ arma_config::atlas = " << arma_config::atlas << '\n'; + out << "@ arma_config::lapack = " << arma_config::lapack << '\n'; + out << "@ arma_config::blas = " << arma_config::blas << '\n'; + out << "@ arma_config::boost = " << arma_config::boost << '\n'; + out << "@ arma_config::boost_date = " << arma_config::boost_date << '\n'; + out << "@ arma_config::good_comp = " << arma_config::good_comp << '\n'; + out << "@ arma_config::extra_code = " << arma_config::extra_code << '\n'; + out << "@ sizeof(void*) = " << sizeof(void*) << '\n'; + out << "@ sizeof(uword) = " << sizeof(uword) << '\n'; + out << "@ sizeof(int) = " << sizeof(int) << '\n'; + out << "@ sizeof(long) = " << sizeof(long) << '\n'; + out << "@ sizeof(blas_int) = " << sizeof(blas_int) << '\n'; + out << "@ little_endian = " << little_endian << '\n'; + out << "@ ---" << std::endl; + } + + }; + + static arma_first_extra_debug_message arma_first_extra_debug_message_run; + } + +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/diagmat_proxy.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/diagmat_proxy.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,339 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup diagmat_proxy +//! @{ + + + +template +class diagmat_proxy + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + inline diagmat_proxy(const Base& X) + : P ( X.get_ref() ) + , P_is_vec( (P.get_n_rows() == 1) || (P.get_n_cols() == 1) ) + , n_elem ( P_is_vec ? P.get_n_elem() : (std::min)(P.get_n_elem(), P.get_n_rows()) ) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (P_is_vec == false) && (P.get_n_rows() != P.get_n_cols()), + "diagmat(): only vectors and square matrices are accepted" + ); + } + + + arma_inline + elem_type + operator[](const uword i) const + { + if( (Proxy::prefer_at_accessor == true) || (P_is_vec == false) ) + { + return P.at(i,i); + } + else + { + return P[i]; + } + } + + + arma_inline + elem_type + at(const uword row, const uword col) const + { + if(row == col) + { + if( (Proxy::prefer_at_accessor == true) || (P_is_vec == false) ) + { + return P.at(row,row); + } + else + { + return P[row]; + } + } + else + { + return elem_type(0); + } + } + + + const Proxy P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy< Mat > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline diagmat_proxy(const Mat& X) + : P(X) + , P_is_vec( (P.n_rows == 1) || (P.n_cols == 1) ) + , n_elem( P_is_vec ? P.n_elem : (std::min)(P.n_elem, P.n_rows) ) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (P_is_vec == false) && (P.n_rows != P.n_cols), + "diagmat(): only vectors and square matrices are accepted" + ); + } + + + arma_inline elem_type operator[] (const uword i) const { return P_is_vec ? P[i] : P.at(i,i); } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? ( P_is_vec ? P[row] : P.at(row,row) ) : elem_type(0); } + + const Mat& P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy< Row > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline diagmat_proxy(const Row& X) + : P(X) + , P_is_vec(true) + , n_elem(P.n_elem) + { + arma_extra_debug_sigprint(); + } + + + arma_inline elem_type operator[] (const uword i) const { return P[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); } + + + const Row& P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy< Col > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline diagmat_proxy(const Col& X) + : P(X) + , P_is_vec(true) + , n_elem(P.n_elem) + { + arma_extra_debug_sigprint(); + } + + + arma_inline elem_type operator[] (const uword i) const { return P[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); } + + + const Col& P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy_check + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + inline diagmat_proxy_check(const Base& X, const Mat& out) + : P(X.get_ref()) + , P_is_vec( (P.n_rows == 1) || (P.n_cols == 1) ) + , n_elem( P_is_vec ? P.n_elem : (std::min)(P.n_elem, P.n_rows) ) + { + arma_extra_debug_sigprint(); + arma_ignore(out); + + arma_debug_check + ( + (P_is_vec == false) && (P.n_rows != P.n_cols), + "diagmat(): only vectors and square matrices are accepted" + ); + } + + + arma_inline elem_type operator[] (const uword i) const { return P_is_vec ? P[i] : P.at(i,i); } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? ( P_is_vec ? P[row] : P.at(row,row) ) : elem_type(0); } + + + const Mat P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy_check< Mat > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + + inline diagmat_proxy_check(const Mat& X, const Mat& out) + : P_local ( (&X == &out) ? new Mat(X) : 0 ) + , P ( (&X == &out) ? (*P_local) : X ) + , P_is_vec( (P.n_rows == 1) || (P.n_cols == 1) ) + , n_elem ( P_is_vec ? P.n_elem : (std::min)(P.n_elem, P.n_rows) ) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (P_is_vec == false) && (P.n_rows != P.n_cols), + "diagmat(): only vectors and square matrices are accepted" + ); + } + + inline ~diagmat_proxy_check() + { + if(P_local) + { + delete P_local; + } + } + + + arma_inline elem_type operator[] (const uword i) const { return P_is_vec ? P[i] : P.at(i,i); } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? ( P_is_vec ? P[row] : P.at(row,row) ) : elem_type(0); } + + + const Mat* P_local; + const Mat& P; + const bool P_is_vec; + const uword n_elem; + }; + + + +template +class diagmat_proxy_check< Row > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + inline diagmat_proxy_check(const Row& X, const Mat& out) + : P_local ( (&X == reinterpret_cast*>(&out)) ? new Row(X) : 0 ) + , P ( (&X == reinterpret_cast*>(&out)) ? (*P_local) : X ) + , P_is_vec(true) + , n_elem (P.n_elem) + { + arma_extra_debug_sigprint(); + } + + + inline ~diagmat_proxy_check() + { + if(P_local) + { + delete P_local; + } + } + + + arma_inline elem_type operator[] (const uword i) const { return P[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); } + + + const Row* P_local; + const Row& P; + const bool P_is_vec; + const uword n_elem; + }; + + + + + + +template +class diagmat_proxy_check< Col > + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + inline diagmat_proxy_check(const Col& X, const Mat& out) + : P_local ( (&X == reinterpret_cast*>(&out)) ? new Col(X) : 0 ) + , P ( (&X == reinterpret_cast*>(&out)) ? (*P_local) : X ) + , P_is_vec(true) + , n_elem (P.n_elem) + { + arma_extra_debug_sigprint(); + } + + + inline ~diagmat_proxy_check() + { + if(P_local) + { + delete P_local; + } + } + + + arma_inline elem_type operator[] (const uword i) const { return P[i]; } + arma_inline elem_type at (const uword row, const uword col) const { return (row == col) ? P[row] : elem_type(0); } + + + const Col* P_local; + const Col& P; + const bool P_is_vec; + const uword n_elem; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/diagview_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/diagview_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,101 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup diagview +//! @{ + + +//! Class for storing data required to extract and set the diagonals of a matrix +template +class diagview : public Base > + { + public: arma_aligned const Mat& m; + protected: arma_aligned Mat* m_ptr; + + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + const uword row_offset; + const uword col_offset; + + const uword n_rows; // equal to n_elem + const uword n_elem; + + static const uword n_cols = 1; + + + protected: + + arma_inline diagview(const Mat& in_m, const uword in_row_offset, const uword in_col_offset, const uword len); + arma_inline diagview( Mat& in_m, const uword in_row_offset, const uword in_col_offset, const uword len); + + + public: + + inline ~diagview(); + + inline void operator=(const diagview& x); + + inline void operator+=(const eT val); + inline void operator-=(const eT val); + inline void operator*=(const eT val); + inline void operator/=(const eT val); + + template inline void operator= (const Base& x); + template inline void operator+=(const Base& x); + template inline void operator-=(const Base& x); + template inline void operator%=(const Base& x); + template inline void operator/=(const Base& x); + + + arma_inline eT& operator[](const uword i); + arma_inline eT operator[](const uword i) const; + + arma_inline eT& at(const uword i); + arma_inline eT at(const uword i) const; + + arma_inline eT& operator()(const uword i); + arma_inline eT operator()(const uword i) const; + + arma_inline eT& at(const uword in_n_row, const uword in_n_col); + arma_inline eT at(const uword in_n_row, const uword in_n_col) const; + + arma_inline eT& operator()(const uword in_n_row, const uword in_n_col); + arma_inline eT operator()(const uword in_n_row, const uword in_n_col) const; + + + inline void fill(const eT val); + inline void zeros(); + inline void ones(); + + inline static void extract(Mat& out, const diagview& in); + + inline static void plus_inplace(Mat& out, const diagview& in); + inline static void minus_inplace(Mat& out, const diagview& in); + inline static void schur_inplace(Mat& out, const diagview& in); + inline static void div_inplace(Mat& out, const diagview& in); + + + private: + + friend class Mat; + friend class subview; + + diagview(); + //diagview(const diagview&); // making this private causes an error under gcc 4.1/4.2, but not 4.3 + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/diagview_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/diagview_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,745 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup diagview +//! @{ + + +template +inline +diagview::~diagview() + { + arma_extra_debug_sigprint(); + } + + +template +arma_inline +diagview::diagview(const Mat& in_m, const uword in_row_offset, const uword in_col_offset, const uword in_len) + : m(in_m) + , m_ptr(0) + , row_offset(in_row_offset) + , col_offset(in_col_offset) + , n_rows(in_len) + , n_elem(in_len) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +diagview::diagview(Mat& in_m, const uword in_row_offset, const uword in_col_offset, const uword in_len) + : m(in_m) + , m_ptr(&in_m) + , row_offset(in_row_offset) + , col_offset(in_col_offset) + , n_rows(in_len) + , n_elem(in_len) + { + arma_extra_debug_sigprint(); + } + + + +//! set a diagonal of our matrix using a diagonal from a foreign matrix +template +inline +void +diagview::operator= (const diagview& x) + { + arma_extra_debug_sigprint(); + + diagview& t = *this; + + arma_debug_check( (t.n_elem != x.n_elem), "diagview: diagonals have incompatible lengths"); + + Mat& t_m = *(t.m_ptr); + const Mat& x_m = x.m; + + if(&t_m != &x_m) + { + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const uword x_row_offset = x.row_offset; + const uword x_col_offset = x.col_offset; + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_m.at(i + x_row_offset, i + x_col_offset); + const eT tmp_j = x_m.at(j + x_row_offset, j + x_col_offset); + + t_m.at(i + t_row_offset, i + t_col_offset) = tmp_i; + t_m.at(j + t_row_offset, j + t_col_offset) = tmp_j; + } + + if(i < t_n_elem) + { + t_m.at(i + t_row_offset, i + t_col_offset) = x_m.at(i + x_row_offset, i + x_col_offset); + } + } + else + { + const Mat tmp = x; + + (*this).operator=(tmp); + } + } + + + +template +inline +void +diagview::operator+=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat& t_m = (*m_ptr); + + const uword t_n_elem = n_elem; + const uword t_row_offset = row_offset; + const uword t_col_offset = col_offset; + + for(uword i=0; i +inline +void +diagview::operator-=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat& t_m = (*m_ptr); + + const uword t_n_elem = n_elem; + const uword t_row_offset = row_offset; + const uword t_col_offset = col_offset; + + for(uword i=0; i +inline +void +diagview::operator*=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat& t_m = (*m_ptr); + + const uword t_n_elem = n_elem; + const uword t_row_offset = row_offset; + const uword t_col_offset = col_offset; + + for(uword i=0; i +inline +void +diagview::operator/=(const eT val) + { + arma_extra_debug_sigprint(); + + Mat& t_m = (*m_ptr); + + const uword t_n_elem = n_elem; + const uword t_row_offset = row_offset; + const uword t_col_offset = col_offset; + + for(uword i=0; i +template +inline +void +diagview::operator= (const Base& o) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(o.get_ref()); + const Mat& x = tmp.M; + + diagview& t = *this; + + arma_debug_check + ( + ( (t.n_elem != x.n_elem) || (x.is_vec() == false) ), + "diagview: given object has incompatible size" + ); + + Mat& t_m = *(t.m_ptr); + + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const eT* x_mem = x.memptr(); + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_mem[i]; + const eT tmp_j = x_mem[j]; + + t_m.at( i + t_row_offset, i + t_col_offset) = tmp_i; + t_m.at( j + t_row_offset, j + t_col_offset) = tmp_j; + } + + if(i < t_n_elem) + { + t_m.at( i + t_row_offset, i + t_col_offset) = x_mem[i]; + } + } + + + +template +template +inline +void +diagview::operator+=(const Base& o) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(o.get_ref()); + const Mat& x = tmp.M; + + diagview& t = *this; + + arma_debug_check + ( + ( (t.n_elem != x.n_elem) || (x.is_vec() == false) ), + "diagview: given object has incompatible size" + ); + + Mat& t_m = *(t.m_ptr); + + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const eT* x_mem = x.memptr(); + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_mem[i]; + const eT tmp_j = x_mem[j]; + + t_m.at( i + t_row_offset, i + t_col_offset) += tmp_i; + t_m.at( j + t_row_offset, j + t_col_offset) += tmp_j; + } + + if(i < t_n_elem) + { + t_m.at( i + t_row_offset, i + t_col_offset) += x_mem[i]; + } + } + + + +template +template +inline +void +diagview::operator-=(const Base& o) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(o.get_ref()); + const Mat& x = tmp.M; + + diagview& t = *this; + + arma_debug_check + ( + ( (t.n_elem != x.n_elem) || (x.is_vec() == false) ), + "diagview: given object has incompatible size" + ); + + Mat& t_m = *(t.m_ptr); + + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const eT* x_mem = x.memptr(); + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_mem[i]; + const eT tmp_j = x_mem[j]; + + t_m.at( i + t_row_offset, i + t_col_offset) -= tmp_i; + t_m.at( j + t_row_offset, j + t_col_offset) -= tmp_j; + } + + if(i < t_n_elem) + { + t_m.at( i + t_row_offset, i + t_col_offset) -= x_mem[i]; + } + } + + + +template +template +inline +void +diagview::operator%=(const Base& o) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(o.get_ref()); + const Mat& x = tmp.M; + + diagview& t = *this; + + arma_debug_check + ( + ( (t.n_elem != x.n_elem) || (x.is_vec() == false) ), + "diagview: given object has incompatible size" + ); + + Mat& t_m = *(t.m_ptr); + + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const eT* x_mem = x.memptr(); + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_mem[i]; + const eT tmp_j = x_mem[j]; + + t_m.at( i + t_row_offset, i + t_col_offset) *= tmp_i; + t_m.at( j + t_row_offset, j + t_col_offset) *= tmp_j; + } + + if(i < t_n_elem) + { + t_m.at( i + t_row_offset, i + t_col_offset) *= x_mem[i]; + } + } + + + +template +template +inline +void +diagview::operator/=(const Base& o) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(o.get_ref()); + const Mat& x = tmp.M; + + diagview& t = *this; + + arma_debug_check + ( + ( (t.n_elem != x.n_elem) || (x.is_vec() == false) ), + "diagview: given object has incompatible size" + ); + + Mat& t_m = *(t.m_ptr); + + const uword t_n_elem = t.n_elem; + const uword t_row_offset = t.row_offset; + const uword t_col_offset = t.col_offset; + + const eT* x_mem = x.memptr(); + + uword i,j; + for(i=0, j=1; j < t_n_elem; i+=2, j+=2) + { + const eT tmp_i = x_mem[i]; + const eT tmp_j = x_mem[j]; + + t_m.at( i + t_row_offset, i + t_col_offset) /= tmp_i; + t_m.at( j + t_row_offset, j + t_col_offset) /= tmp_j; + } + + if(i < t_n_elem) + { + t_m.at( i + t_row_offset, i + t_col_offset) /= x_mem[i]; + } + } + + + +//! extract a diagonal and store it as a column vector +template +inline +void +diagview::extract(Mat& out, const diagview& in) + { + arma_extra_debug_sigprint(); + + // NOTE: we're assuming that the matrix has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Mat contructor or operator=() + + const Mat& in_m = in.m; + + const uword in_n_elem = in.n_elem; + const uword in_row_offset = in.row_offset; + const uword in_col_offset = in.col_offset; + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j < in_n_elem; i+=2, j+=2) + { + const eT tmp_i = in_m.at( i + in_row_offset, i + in_col_offset ); + const eT tmp_j = in_m.at( j + in_row_offset, j + in_col_offset ); + + out_mem[i] = tmp_i; + out_mem[j] = tmp_j; + } + + if(i < in_n_elem) + { + out_mem[i] = in_m.at( i + in_row_offset, i + in_col_offset ); + } + } + + + +//! X += Y.diag() +template +inline +void +diagview::plus_inplace(Mat& out, const diagview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, in.n_rows, in.n_cols, "addition"); + + const Mat& in_m = in.m; + + const uword in_n_elem = in.n_elem; + const uword in_row_offset = in.row_offset; + const uword in_col_offset = in.col_offset; + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j < in_n_elem; i+=2, j+=2) + { + const eT tmp_i = in_m.at( i + in_row_offset, i + in_col_offset ); + const eT tmp_j = in_m.at( j + in_row_offset, j + in_col_offset ); + + out_mem[i] += tmp_i; + out_mem[j] += tmp_j; + } + + if(i < in_n_elem) + { + out_mem[i] += in_m.at( i + in_row_offset, i + in_col_offset ); + } + } + + + +//! X -= Y.diag() +template +inline +void +diagview::minus_inplace(Mat& out, const diagview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, in.n_rows, in.n_cols, "subtraction"); + + const Mat& in_m = in.m; + + const uword in_n_elem = in.n_elem; + const uword in_row_offset = in.row_offset; + const uword in_col_offset = in.col_offset; + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j < in_n_elem; i+=2, j+=2) + { + const eT tmp_i = in_m.at( i + in_row_offset, i + in_col_offset ); + const eT tmp_j = in_m.at( j + in_row_offset, j + in_col_offset ); + + out_mem[i] -= tmp_i; + out_mem[j] -= tmp_j; + } + + if(i < in_n_elem) + { + out_mem[i] -= in_m.at( i + in_row_offset, i + in_col_offset ); + } + } + + + +//! X %= Y.diag() +template +inline +void +diagview::schur_inplace(Mat& out, const diagview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, in.n_rows, in.n_cols, "element-wise multiplication"); + + const Mat& in_m = in.m; + + const uword in_n_elem = in.n_elem; + const uword in_row_offset = in.row_offset; + const uword in_col_offset = in.col_offset; + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j < in_n_elem; i+=2, j+=2) + { + const eT tmp_i = in_m.at( i + in_row_offset, i + in_col_offset ); + const eT tmp_j = in_m.at( j + in_row_offset, j + in_col_offset ); + + out_mem[i] *= tmp_i; + out_mem[j] *= tmp_j; + } + + if(i < in_n_elem) + { + out_mem[i] *= in_m.at( i + in_row_offset, i + in_col_offset ); + } + } + + + +//! X /= Y.diag() +template +inline +void +diagview::div_inplace(Mat& out, const diagview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, in.n_rows, in.n_cols, "element-wise division"); + + const Mat& in_m = in.m; + + const uword in_n_elem = in.n_elem; + const uword in_row_offset = in.row_offset; + const uword in_col_offset = in.col_offset; + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j < in_n_elem; i+=2, j+=2) + { + const eT tmp_i = in_m.at( i + in_row_offset, i + in_col_offset ); + const eT tmp_j = in_m.at( j + in_row_offset, j + in_col_offset ); + + out_mem[i] /= tmp_i; + out_mem[j] /= tmp_j; + } + + if(i < in_n_elem) + { + out_mem[i] /= in_m.at( i + in_row_offset, i + in_col_offset ); + } + } + + + +template +arma_inline +eT& +diagview::operator[](const uword i) + { + return (*m_ptr).at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT +diagview::operator[](const uword i) const + { + return m.at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT& +diagview::at(const uword i) + { + return (*m_ptr).at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT +diagview::at(const uword i) const + { + return m.at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT& +diagview::operator()(const uword i) + { + arma_debug_check( (i >= n_elem), "diagview::operator(): out of bounds" ); + + return (*m_ptr).at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT +diagview::operator()(const uword i) const + { + arma_debug_check( (i >= n_elem), "diagview::operator(): out of bounds" ); + + return m.at(i+row_offset, i+col_offset); + } + + + +template +arma_inline +eT& +diagview::at(const uword row, const uword col) + { + return (*m_ptr).at(row+row_offset, row+col_offset); + } + + + +template +arma_inline +eT +diagview::at(const uword row, const uword col) const + { + return m.at(row+row_offset, row+col_offset); + } + + + +template +arma_inline +eT& +diagview::operator()(const uword row, const uword col) + { + arma_debug_check( ((row >= n_elem) || (col > 0)), "diagview::operator(): out of bounds" ); + + return (*m_ptr).at(row+row_offset, row+col_offset); + } + + + +template +arma_inline +eT +diagview::operator()(const uword row, const uword col) const + { + arma_debug_check( ((row >= n_elem) || (col > 0)), "diagview::operator(): out of bounds" ); + + return m.at(row+row_offset, row+col_offset); + } + + + +template +inline +void +diagview::fill(const eT val) + { + arma_extra_debug_sigprint(); + + Mat& x = (*m_ptr); + + for(uword i=0; i +inline +void +diagview::zeros() + { + arma_extra_debug_sigprint(); + + (*this).fill(eT(0)); + } + + + +template +inline +void +diagview::ones() + { + arma_extra_debug_sigprint(); + + (*this).fill(eT(1)); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/diskio_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/diskio_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,159 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Ian Cullinan +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup diskio +//! @{ + + +//! class for saving and loading matrices and fields +class diskio + { + public: + + template inline static std::string gen_txt_header(const Mat& x); + template inline static std::string gen_bin_header(const Mat& x); + + template inline static std::string gen_txt_header(const Cube& x); + template inline static std::string gen_bin_header(const Cube& x); + + inline static file_type guess_file_type(std::istream& f); + + inline static char conv_to_hex_char(const u8 x); + inline static void conv_to_hex(char* out, const u8 x); + + inline static std::string gen_tmp_name(const std::string& x); + + inline static bool safe_rename(const std::string& old_name, const std::string& new_name); + + + // + // matrix saving + + template inline static bool save_raw_ascii (const Mat& x, const std::string& final_name); + template inline static bool save_raw_binary (const Mat& x, const std::string& final_name); + template inline static bool save_arma_ascii (const Mat& x, const std::string& final_name); + template inline static bool save_csv_ascii (const Mat& x, const std::string& final_name); + template inline static bool save_arma_binary(const Mat& x, const std::string& final_name); + template inline static bool save_pgm_binary (const Mat& x, const std::string& final_name); + template inline static bool save_pgm_binary (const Mat< std::complex >& x, const std::string& final_name); + + template inline static bool save_raw_ascii (const Mat& x, std::ostream& f); + template inline static bool save_raw_binary (const Mat& x, std::ostream& f); + template inline static bool save_arma_ascii (const Mat& x, std::ostream& f); + template inline static bool save_csv_ascii (const Mat& x, std::ostream& f); + template inline static bool save_arma_binary(const Mat& x, std::ostream& f); + template inline static bool save_pgm_binary (const Mat& x, std::ostream& f); + template inline static bool save_pgm_binary (const Mat< std::complex >& x, std::ostream& f); + + + // + // matrix loading + + template inline static bool load_raw_ascii (Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_raw_binary (Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_arma_ascii (Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_csv_ascii (Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_arma_binary(Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_pgm_binary (Mat& x, const std::string& name, std::string& err_msg); + template inline static bool load_pgm_binary (Mat< std::complex >& x, const std::string& name, std::string& err_msg); + template inline static bool load_auto_detect(Mat& x, const std::string& name, std::string& err_msg); + + template inline static bool load_raw_ascii (Mat& x, std::istream& f, std::string& err_msg); + template inline static bool load_raw_binary (Mat& x, std::istream& f, std::string& err_msg); + template inline static bool load_arma_ascii (Mat& x, std::istream& f, std::string& err_msg); + template inline static bool load_csv_ascii (Mat& x, std::istream& f, std::string& err_msg); + template inline static bool load_arma_binary(Mat& x, std::istream& f, std::string& err_msg); + template inline static bool load_pgm_binary (Mat& x, std::istream& is, std::string& err_msg); + template inline static bool load_pgm_binary (Mat< std::complex >& x, std::istream& is, std::string& err_msg); + template inline static bool load_auto_detect(Mat& x, std::istream& f, std::string& err_msg); + + inline static void pnm_skip_comments(std::istream& f); + + + // + // cube saving + + template inline static bool save_raw_ascii (const Cube& x, const std::string& name); + template inline static bool save_raw_binary (const Cube& x, const std::string& name); + template inline static bool save_arma_ascii (const Cube& x, const std::string& name); + template inline static bool save_arma_binary(const Cube& x, const std::string& name); + + template inline static bool save_raw_ascii (const Cube& x, std::ostream& f); + template inline static bool save_raw_binary (const Cube& x, std::ostream& f); + template inline static bool save_arma_ascii (const Cube& x, std::ostream& f); + template inline static bool save_arma_binary(const Cube& x, std::ostream& f); + + + // + // cube loading + + template inline static bool load_raw_ascii (Cube& x, const std::string& name, std::string& err_msg); + template inline static bool load_raw_binary (Cube& x, const std::string& name, std::string& err_msg); + template inline static bool load_arma_ascii (Cube& x, const std::string& name, std::string& err_msg); + template inline static bool load_arma_binary(Cube& x, const std::string& name, std::string& err_msg); + template inline static bool load_auto_detect(Cube& x, const std::string& name, std::string& err_msg); + + template inline static bool load_raw_ascii (Cube& x, std::istream& f, std::string& err_msg); + template inline static bool load_raw_binary (Cube& x, std::istream& f, std::string& err_msg); + template inline static bool load_arma_ascii (Cube& x, std::istream& f, std::string& err_msg); + template inline static bool load_arma_binary(Cube& x, std::istream& f, std::string& err_msg); + template inline static bool load_auto_detect(Cube& x, std::istream& f, std::string& err_msg); + + + // + // field saving and loading + + template inline static bool save_arma_binary(const field& x, const std::string& name); + template inline static bool save_arma_binary(const field& x, std::ostream& f); + + template inline static bool load_arma_binary( field& x, const std::string& name, std::string& err_msg); + template inline static bool load_arma_binary( field& x, std::istream& f, std::string& err_msg); + + template inline static bool load_auto_detect( field& x, const std::string& name, std::string& err_msg); + template inline static bool load_auto_detect( field& x, std::istream& f, std::string& err_msg); + + inline static bool save_std_string(const field& x, const std::string& name); + inline static bool save_std_string(const field& x, std::ostream& f); + + inline static bool load_std_string( field& x, const std::string& name, std::string& err_msg); + inline static bool load_std_string( field& x, std::istream& f, std::string& err_msg); + + + + // + // handling of PPM images by cubes + + template inline static bool save_ppm_binary(const Cube& x, const std::string& final_name); + template inline static bool save_ppm_binary(const Cube& x, std::ostream& f); + + template inline static bool load_ppm_binary( Cube& x, const std::string& final_name, std::string& err_msg); + template inline static bool load_ppm_binary( Cube& x, std::istream& f, std::string& err_msg); + + + // + // handling of PPM images by fields + + template inline static bool save_ppm_binary(const field& x, const std::string& final_name); + template inline static bool save_ppm_binary(const field& x, std::ostream& f); + + template inline static bool load_ppm_binary( field& x, const std::string& final_name, std::string& err_msg); + template inline static bool load_ppm_binary( field& x, std::istream& f, std::string& err_msg); + + + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/diskio_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/diskio_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,3118 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Ian Cullinan +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup diskio +//! @{ + + +//! Generate the first line of the header used for saving matrices in text format. +//! Format: "ARMA_MAT_TXT_ABXYZ". +//! A is one of: I (for integral types) or F (for floating point types). +//! B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). +//! XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. +template +inline +std::string +diskio::gen_txt_header(const Mat& x) + { + arma_type_check(( is_supported_elem_type::value == false )); + + arma_ignore(x); + + if(is_u8::value == true) + { + return std::string("ARMA_MAT_TXT_IU001"); + } + else + if(is_s8::value == true) + { + return std::string("ARMA_MAT_TXT_IS001"); + } + else + if(is_u16::value == true) + { + return std::string("ARMA_MAT_TXT_IU002"); + } + else + if(is_s16::value == true) + { + return std::string("ARMA_MAT_TXT_IS002"); + } + else + if(is_u32::value == true) + { + return std::string("ARMA_MAT_TXT_IU004"); + } + else + if(is_s32::value == true) + { + return std::string("ARMA_MAT_TXT_IS004"); + } +#if defined(ARMA_64BIT_WORD) + else + if(is_u64::value == true) + { + return std::string("ARMA_MAT_TXT_IU008"); + } + else + if(is_s64::value == true) + { + return std::string("ARMA_MAT_TXT_IS008"); + } +#endif + else + if(is_float::value == true) + { + return std::string("ARMA_MAT_TXT_FN004"); + } + else + if(is_double::value == true) + { + return std::string("ARMA_MAT_TXT_FN008"); + } + else + if(is_complex_float::value == true) + { + return std::string("ARMA_MAT_TXT_FC008"); + } + else + if(is_complex_double::value == true) + { + return std::string("ARMA_MAT_TXT_FC016"); + } + else + { + return std::string(); + } + + } + + + +//! Generate the first line of the header used for saving matrices in binary format. +//! Format: "ARMA_MAT_BIN_ABXYZ". +//! A is one of: I (for integral types) or F (for floating point types). +//! B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). +//! XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. +template +inline +std::string +diskio::gen_bin_header(const Mat& x) + { + arma_type_check(( is_supported_elem_type::value == false )); + + arma_ignore(x); + + if(is_u8::value == true) + { + return std::string("ARMA_MAT_BIN_IU001"); + } + else + if(is_s8::value == true) + { + return std::string("ARMA_MAT_BIN_IS001"); + } + else + if(is_u16::value == true) + { + return std::string("ARMA_MAT_BIN_IU002"); + } + else + if(is_s16::value == true) + { + return std::string("ARMA_MAT_BIN_IS002"); + } + else + if(is_u32::value == true) + { + return std::string("ARMA_MAT_BIN_IU004"); + } + else + if(is_s32::value == true) + { + return std::string("ARMA_MAT_BIN_IS004"); + } +#if defined(ARMA_64BIT_WORD) + else + if(is_u64::value == true) + { + return std::string("ARMA_MAT_BIN_IU008"); + } + else + if(is_s64::value == true) + { + return std::string("ARMA_MAT_BIN_IS008"); + } +#endif + else + if(is_float::value == true) + { + return std::string("ARMA_MAT_BIN_FN004"); + } + else + if(is_double::value == true) + { + return std::string("ARMA_MAT_BIN_FN008"); + } + else + if(is_complex_float::value == true) + { + return std::string("ARMA_MAT_BIN_FC008"); + } + else + if(is_complex_double::value == true) + { + return std::string("ARMA_MAT_BIN_FC016"); + } + else + { + return std::string(); + } + + } + + + +//! Generate the first line of the header used for saving cubes in text format. +//! Format: "ARMA_CUB_TXT_ABXYZ". +//! A is one of: I (for integral types) or F (for floating point types). +//! B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). +//! XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. +template +inline +std::string +diskio::gen_txt_header(const Cube& x) + { + arma_type_check(( is_supported_elem_type::value == false )); + + arma_ignore(x); + + if(is_u8::value == true) + { + return std::string("ARMA_CUB_TXT_IU001"); + } + else + if(is_s8::value == true) + { + return std::string("ARMA_CUB_TXT_IS001"); + } + else + if(is_u16::value == true) + { + return std::string("ARMA_CUB_TXT_IU002"); + } + else + if(is_s16::value == true) + { + return std::string("ARMA_CUB_TXT_IS002"); + } + else + if(is_u32::value == true) + { + return std::string("ARMA_CUB_TXT_IU004"); + } + else + if(is_s32::value == true) + { + return std::string("ARMA_CUB_TXT_IS004"); + } +#if defined(ARMA_64BIT_WORD) + else + if(is_u64::value == true) + { + return std::string("ARMA_CUB_TXT_IU008"); + } + else + if(is_s64::value == true) + { + return std::string("ARMA_CUB_TXT_IS008"); + } +#endif + else + if(is_float::value == true) + { + return std::string("ARMA_CUB_TXT_FN004"); + } + else + if(is_double::value == true) + { + return std::string("ARMA_CUB_TXT_FN008"); + } + else + if(is_complex_float::value == true) + { + return std::string("ARMA_CUB_TXT_FC008"); + } + else + if(is_complex_double::value == true) + { + return std::string("ARMA_CUB_TXT_FC016"); + } + else + { + return std::string(); + } + + } + + + +//! Generate the first line of the header used for saving cubes in binary format. +//! Format: "ARMA_CUB_BIN_ABXYZ". +//! A is one of: I (for integral types) or F (for floating point types). +//! B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). +//! XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. +template +inline +std::string +diskio::gen_bin_header(const Cube& x) + { + arma_type_check(( is_supported_elem_type::value == false )); + + arma_ignore(x); + + if(is_u8::value == true) + { + return std::string("ARMA_CUB_BIN_IU001"); + } + else + if(is_s8::value == true) + { + return std::string("ARMA_CUB_BIN_IS001"); + } + else + if(is_u16::value == true) + { + return std::string("ARMA_CUB_BIN_IU002"); + } + else + if(is_s16::value == true) + { + return std::string("ARMA_CUB_BIN_IS002"); + } + else + if(is_u32::value == true) + { + return std::string("ARMA_CUB_BIN_IU004"); + } + else + if(is_s32::value == true) + { + return std::string("ARMA_CUB_BIN_IS004"); + } +#if defined(ARMA_64BIT_WORD) + else + if(is_u64::value == true) + { + return std::string("ARMA_CUB_BIN_IU008"); + } + else + if(is_s64::value == true) + { + return std::string("ARMA_CUB_BIN_IS008"); + } +#endif + else + if(is_float::value == true) + { + return std::string("ARMA_CUB_BIN_FN004"); + } + else + if(is_double::value == true) + { + return std::string("ARMA_CUB_BIN_FN008"); + } + else + if(is_complex_float::value == true) + { + return std::string("ARMA_CUB_BIN_FC008"); + } + else + if(is_complex_double::value == true) + { + return std::string("ARMA_CUB_BIN_FC016"); + } + else + { + return std::string(); + } + + } + + + +inline +file_type +diskio::guess_file_type(std::istream& f) + { + arma_extra_debug_sigprint(); + + f.clear(); + const std::fstream::pos_type pos1 = f.tellg(); + + f.clear(); + f.seekg(0, ios::end); + + f.clear(); + const std::fstream::pos_type pos2 = f.tellg(); + + const uword N = ( (pos1 >= 0) && (pos2 >= 0) ) ? uword(pos2 - pos1) : 0; + + f.clear(); + f.seekg(pos1); + + podarray data(N); + + unsigned char* ptr = data.memptr(); + + f.clear(); + f.read( reinterpret_cast(ptr), std::streamsize(N) ); + + const bool load_okay = f.good(); + + f.clear(); + f.seekg(pos1); + + bool has_binary = false; + bool has_comma = false; + + if(load_okay == true) + { + uword i = 0; + uword j = (N >= 2) ? 1 : 0; + + for(; j= 123)) || ((val_j <= 8) || (val_j >= 123)) ) + { + has_binary = true; + break; + } + + if( (val_i == ',') || (val_j == ',') ) + { + has_comma = true; + break; + } + } + } + else + { + return file_type_unknown; + } + + if(has_binary) + { + return raw_binary; + } + + if(has_comma) + { + return csv_ascii; + } + + return raw_ascii; + } + + + +inline +char +diskio::conv_to_hex_char(const u8 x) + { + char out; + + switch(x) + { + case 0: out = '0'; break; + case 1: out = '1'; break; + case 2: out = '2'; break; + case 3: out = '3'; break; + case 4: out = '4'; break; + case 5: out = '5'; break; + case 6: out = '6'; break; + case 7: out = '7'; break; + case 8: out = '8'; break; + case 9: out = '9'; break; + case 10: out = 'a'; break; + case 11: out = 'b'; break; + case 12: out = 'c'; break; + case 13: out = 'd'; break; + case 14: out = 'e'; break; + case 15: out = 'f'; break; + default: out = '-'; break; + } + + return out; + } + + + +inline +void +diskio::conv_to_hex(char* out, const u8 x) + { + const u8 a = x / 16; + const u8 b = x - 16*a; + + out[0] = conv_to_hex_char(a); + out[1] = conv_to_hex_char(b); + } + + + +//! Append a quasi-random string to the given filename. +//! The rand() function is deliberately not used, +//! as rand() has an internal state that changes +//! from call to call. Such states should not be +//! modified in scientific applications, where the +//! results should be reproducable and not affected +//! by saving data. +inline +std::string +diskio::gen_tmp_name(const std::string& x) + { + const std::string* ptr_x = &x; + const u8* ptr_ptr_x = reinterpret_cast(&ptr_x); + + const char* extra = ".tmp_"; + const uword extra_size = 5; + + const uword tmp_size = 2*sizeof(u8*) + 2*2; + char tmp[tmp_size]; + + uword char_count = 0; + + for(uword i=0; i(x.size()); + u8 sum = 0; + + for(uword i=0; i +inline +bool +diskio::save_raw_ascii(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::fstream f(tmp_name.c_str(), std::fstream::out); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_raw_ascii(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a matrix as raw text (no header, human readable). +//! Matrices can be loaded in Matlab and Octave, as long as they don't have complex elements. +template +inline +bool +diskio::save_raw_ascii(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + uword cell_width; + + // TODO: need sane values for complex numbers + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.setf(ios::scientific); + f.precision(10); + cell_width = 18; + } + + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f.put(' '); + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.width(cell_width); + } + + f << x.at(row,col); + } + + f.put('\n'); + } + + return f.good(); + } + + + +//! Save a matrix as raw binary (no header) +template +inline +bool +diskio::save_raw_binary(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str(), std::fstream::binary); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_raw_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +template +inline +bool +diskio::save_raw_binary(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + f.write( reinterpret_cast(x.mem), std::streamsize(x.n_elem*sizeof(eT)) ); + + return f.good(); + } + + + +//! Save a matrix in text format (human readable), +//! with a header that indicates the matrix type as well as its dimensions +template +inline +bool +diskio::save_arma_ascii(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str()); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_arma_ascii(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a matrix in text format (human readable), +//! with a header that indicates the matrix type as well as its dimensions +template +inline +bool +diskio::save_arma_ascii(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + const ios::fmtflags orig_flags = f.flags(); + + f << diskio::gen_txt_header(x) << '\n'; + f << x.n_rows << ' ' << x.n_cols << '\n'; + + uword cell_width; + + // TODO: need sane values for complex numbers + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.setf(ios::scientific); + f.precision(10); + cell_width = 18; + } + + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f.put(' '); + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.width(cell_width); + } + + f << x.at(row,col); + } + + f.put('\n'); + } + + const bool save_okay = f.good(); + + f.flags(orig_flags); + + return save_okay; + } + + + +//! Save a matrix in CSV text format (human readable) +template +inline +bool +diskio::save_csv_ascii(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str()); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_csv_ascii(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a matrix in CSV text format (human readable) +template +inline +bool +diskio::save_csv_ascii(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + const ios::fmtflags orig_flags = f.flags(); + + // TODO: need sane values for complex numbers + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.setf(ios::scientific); + f.precision(10); + } + + uword x_n_rows = x.n_rows; + uword x_n_cols = x.n_cols; + + for(uword row=0; row < x_n_rows; ++row) + { + for(uword col=0; col < x_n_cols; ++col) + { + f << x.at(row,col); + + if( col < (x_n_cols-1) ) + { + f.put(','); + } + } + + f.put('\n'); + } + + const bool save_okay = f.good(); + + f.flags(orig_flags); + + return save_okay; + } + + + +//! Save a matrix in binary format, +//! with a header that stores the matrix type as well as its dimensions +template +inline +bool +diskio::save_arma_binary(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str(), std::fstream::binary); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_arma_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a matrix in binary format, +//! with a header that stores the matrix type as well as its dimensions +template +inline +bool +diskio::save_arma_binary(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + f << diskio::gen_bin_header(x) << '\n'; + f << x.n_rows << ' ' << x.n_cols << '\n'; + + f.write( reinterpret_cast(x.mem), std::streamsize(x.n_elem*sizeof(eT)) ); + + return f.good(); + } + + + +//! Save a matrix as a PGM greyscale image +template +inline +bool +diskio::save_pgm_binary(const Mat& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::fstream f(tmp_name.c_str(), std::fstream::out | std::fstream::binary); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_pgm_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +// +// TODO: +// add functionality to save the image in a normalised format, +// i.e. scaled so that every value falls in the [0,255] range. + +//! Save a matrix as a PGM greyscale image +template +inline +bool +diskio::save_pgm_binary(const Mat& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + f << "P5" << '\n'; + f << x.n_cols << ' ' << x.n_rows << '\n'; + f << 255 << '\n'; + + const uword n_elem = x.n_rows * x.n_cols; + podarray tmp(n_elem); + + uword i = 0; + + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + tmp[i] = u8( x.at(row,col) ); // TODO: add round() ? + ++i; + } + } + + f.write(reinterpret_cast(tmp.mem), std::streamsize(n_elem) ); + + return f.good(); + } + + + +//! Save a matrix as a PGM greyscale image +template +inline +bool +diskio::save_pgm_binary(const Mat< std::complex >& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const uchar_mat tmp = conv_to::from(x); + + return diskio::save_pgm_binary(tmp, final_name); + } + + + +//! Save a matrix as a PGM greyscale image +template +inline +bool +diskio::save_pgm_binary(const Mat< std::complex >& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + const uchar_mat tmp = conv_to::from(x); + + return diskio::save_pgm_binary(tmp, f); + } + + + +//! Load a matrix as raw text (no header, human readable). +//! Can read matrices saved as text in Matlab and Octave. +//! NOTE: this is much slower than reading a file with a header. +template +inline +bool +diskio::load_raw_ascii(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_raw_ascii(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Load a matrix as raw text (no header, human readable). +//! Can read matrices saved as text in Matlab and Octave. +//! NOTE: this is much slower than reading a file with a header. +template +inline +bool +diskio::load_raw_ascii(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = f.good(); + + f.clear(); + const std::fstream::pos_type pos1 = f.tellg(); + + // + // work out the size + + uword f_n_rows = 0; + uword f_n_cols = 0; + + bool f_n_cols_found = false; + + std::string line_string; + std::string token; + + while( (f.good() == true) && (load_okay == true) ) + { + std::getline(f, line_string); + + if(line_string.size() == 0) + { + break; + } + + std::stringstream line_stream(line_string); + + uword line_n_cols = 0; + + while (line_stream >> token) + { + ++line_n_cols; + } + + if(f_n_cols_found == false) + { + f_n_cols = line_n_cols; + f_n_cols_found = true; + } + else + { + if(line_n_cols != f_n_cols) + { + err_msg = "inconsistent number of columns in "; + load_okay = false; + } + } + + ++f_n_rows; + } + + if(load_okay == true) + { + f.clear(); + f.seekg(pos1); + + x.set_size(f_n_rows, f_n_cols); + + eT val; + + for(uword row=0; (row < x.n_rows) && (load_okay == true); ++row) + { + for(uword col=0; (col < x.n_cols) && (load_okay == true); ++col) + { + f >> val; + + if(f.fail() == false) + { + x.at(row,col) = val; + } + else + { + load_okay = false; + err_msg = "couldn't interpret data in "; + //break; + } + } + } + } + + + // an empty file indicates an empty matrix + if( (f_n_cols_found == false) && (load_okay == true) ) + { + x.reset(); + } + + + return load_okay; + } + + + +//! Load a matrix in binary format (no header); +//! the matrix is assumed to have one column +template +inline +bool +diskio::load_raw_binary(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f; + f.open(name.c_str(), std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_raw_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_raw_binary(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + arma_ignore(err_msg); + + f.clear(); + const std::streampos pos1 = f.tellg(); + + f.clear(); + f.seekg(0, ios::end); + + f.clear(); + const std::streampos pos2 = f.tellg(); + + const uword N = ( (pos1 >= 0) && (pos2 >= 0) ) ? uword(pos2 - pos1) : 0; + + f.clear(); + //f.seekg(0, ios::beg); + f.seekg(pos1); + + x.set_size(N / sizeof(eT), 1); + + f.clear(); + f.read( reinterpret_cast(x.memptr()), std::streamsize(N) ); + + return f.good(); + } + + + +//! Load a matrix in text format (human readable), +//! with a header that indicates the matrix type as well as its dimensions +template +inline +bool +diskio::load_arma_ascii(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f(name.c_str()); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_arma_ascii(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Load a matrix in text format (human readable), +//! with a header that indicates the matrix type as well as its dimensions +template +inline +bool +diskio::load_arma_ascii(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + std::string f_header; + uword f_n_rows; + uword f_n_cols; + + f >> f_header; + f >> f_n_rows; + f >> f_n_cols; + + if(f_header == diskio::gen_txt_header(x)) + { + x.set_size(f_n_rows, f_n_cols); + + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f >> x.at(row,col); + } + } + + load_okay = f.good(); + } + else + { + load_okay = false; + err_msg = "incorrect header in "; + } + + return load_okay; + } + + + +//! Load a matrix in CSV text format (human readable) +template +inline +bool +diskio::load_csv_ascii(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_csv_ascii(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Load a matrix in CSV text format (human readable) +template +inline +bool +diskio::load_csv_ascii(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = f.good(); + + f.clear(); + const std::fstream::pos_type pos1 = f.tellg(); + + // + // work out the size + + uword f_n_rows = 0; + uword f_n_cols = 0; + + std::string line_string; + std::string token; + + while( (f.good() == true) && (load_okay == true) ) + { + std::getline(f, line_string); + + if(line_string.size() == 0) + { + break; + } + + std::stringstream line_stream(line_string); + + uword line_n_cols = 0; + + while(line_stream.good() == true) + { + getline(line_stream, token, ','); + ++line_n_cols; + } + + if(f_n_cols < line_n_cols) + { + f_n_cols = line_n_cols; + } + + ++f_n_rows; + } + + f.clear(); + f.seekg(pos1); + + x.zeros(f_n_rows, f_n_cols); + + uword row = 0; + + while(f.good() == true) + { + std::getline(f, line_string); + + if(line_string.size() == 0) + { + break; + } + + std::stringstream line_stream(line_string); + + uword col = 0; + + while(line_stream.good() == true) + { + getline(line_stream, token, ','); + + eT val; + + std::stringstream ss(token); + + ss >> val; + + if(ss.fail() == false) + { + x.at(row,col) = val; + } + + ++col; + } + + ++row; + } + + return load_okay; + } + + + +//! Load a matrix in binary format, +//! with a header that indicates the matrix type as well as its dimensions +template +inline +bool +diskio::load_arma_binary(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f; + f.open(name.c_str(), std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_arma_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_arma_binary(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + std::string f_header; + uword f_n_rows; + uword f_n_cols; + + f >> f_header; + f >> f_n_rows; + f >> f_n_cols; + + if(f_header == diskio::gen_bin_header(x)) + { + //f.seekg(1, ios::cur); // NOTE: this may not be portable, as on a Windows machine a newline could be two characters + f.get(); + + x.set_size(f_n_rows,f_n_cols); + f.read( reinterpret_cast(x.memptr()), std::streamsize(x.n_elem*sizeof(eT)) ); + + load_okay = f.good(); + } + else + { + load_okay = false; + err_msg = "incorrect header in "; + } + + return load_okay; + } + + + +inline +void +diskio::pnm_skip_comments(std::istream& f) + { + while( isspace(f.peek()) ) + { + while( isspace(f.peek()) ) + { + f.get(); + } + + if(f.peek() == '#') + { + while( (f.peek() != '\r') && (f.peek()!='\n') ) + { + f.get(); + } + } + } + } + + + +//! Load a PGM greyscale image as a matrix +template +inline +bool +diskio::load_pgm_binary(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_pgm_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Load a PGM greyscale image as a matrix +template +inline +bool +diskio::load_pgm_binary(Mat& x, std::istream& f, std::string& err_msg) + { + bool load_okay = true; + + std::string f_header; + f >> f_header; + + if(f_header == "P5") + { + uword f_n_rows = 0; + uword f_n_cols = 0; + int f_maxval = 0; + + diskio::pnm_skip_comments(f); + + f >> f_n_cols; + diskio::pnm_skip_comments(f); + + f >> f_n_rows; + diskio::pnm_skip_comments(f); + + f >> f_maxval; + f.get(); + + if( (f_maxval > 0) || (f_maxval <= 65535) ) + { + x.set_size(f_n_rows,f_n_cols); + + if(f_maxval <= 255) + { + const uword n_elem = f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(n_elem) ); + + uword i = 0; + + //cout << "f_n_cols = " << f_n_cols << endl; + //cout << "f_n_rows = " << f_n_rows << endl; + + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + x.at(row,col) = eT(tmp[i]); + ++i; + } + } + + } + else + { + const uword n_elem = f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(n_elem*2) ); + + uword i = 0; + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + x.at(row,col) = eT(tmp[i]); + ++i; + } + } + + } + + } + else + { + load_okay = false; + err_msg = "currently no code available to handle loading "; + } + + if(f.good() == false) + { + load_okay = false; + } + } + else + { + load_okay = false; + err_msg = "unsupported header in "; + } + + return load_okay; + } + + + +//! Load a PGM greyscale image as a matrix +template +inline +bool +diskio::load_pgm_binary(Mat< std::complex >& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + uchar_mat tmp; + const bool load_okay = diskio::load_pgm_binary(tmp, name, err_msg); + + x = conv_to< Mat< std::complex > >::from(tmp); + + return load_okay; + } + + + +//! Load a PGM greyscale image as a matrix +template +inline +bool +diskio::load_pgm_binary(Mat< std::complex >& x, std::istream& is, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + uchar_mat tmp; + const bool load_okay = diskio::load_pgm_binary(tmp, is, err_msg); + + x = conv_to< Mat< std::complex > >::from(tmp); + + return load_okay; + } + + + +//! Try to load a matrix by automatically determining its type +template +inline +bool +diskio::load_auto_detect(Mat& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_auto_detect(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Try to load a matrix by automatically determining its type +template +inline +bool +diskio::load_auto_detect(Mat& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + static const std::string ARMA_MAT_TXT = "ARMA_MAT_TXT"; + static const std::string ARMA_MAT_BIN = "ARMA_MAT_BIN"; + static const std::string P5 = "P5"; + + podarray raw_header(ARMA_MAT_TXT.length() + 1); + + std::streampos pos = f.tellg(); + + f.read( raw_header.memptr(), std::streamsize(ARMA_MAT_TXT.length()) ); + raw_header[ARMA_MAT_TXT.length()] = '\0'; + + f.clear(); + f.seekg(pos); + + const std::string header = raw_header.mem; + + if(ARMA_MAT_TXT == header.substr(0,ARMA_MAT_TXT.length())) + { + return load_arma_ascii(x, f, err_msg); + } + else + if(ARMA_MAT_BIN == header.substr(0,ARMA_MAT_BIN.length())) + { + return load_arma_binary(x, f, err_msg); + } + else + if(P5 == header.substr(0,P5.length())) + { + return load_pgm_binary(x, f, err_msg); + } + else + { + const file_type ft = guess_file_type(f); + + switch(ft) + { + case csv_ascii: + return load_csv_ascii(x, f, err_msg); + break; + + case raw_binary: + return load_raw_binary(x, f, err_msg); + break; + + case raw_ascii: + return load_raw_ascii(x, f, err_msg); + break; + + default: + err_msg = "unknown data in "; + return false; + } + } + + return false; + } + + + +// cubes + + + +//! Save a cube as raw text (no header, human readable). +template +inline +bool +diskio::save_raw_ascii(const Cube& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::fstream f(tmp_name.c_str(), std::fstream::out); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = save_raw_ascii(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a cube as raw text (no header, human readable). +template +inline +bool +diskio::save_raw_ascii(const Cube& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + uword cell_width; + + // TODO: need sane values for complex numbers + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.setf(ios::scientific); + f.precision(10); + cell_width = 18; + } + + for(uword slice=0; slice < x.n_slices; ++slice) + { + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f.put(' '); + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.width(cell_width); + } + + f << x.at(row,col,slice); + } + + f.put('\n'); + } + } + + return f.good(); + } + + + +//! Save a cube as raw binary (no header) +template +inline +bool +diskio::save_raw_binary(const Cube& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str(), std::fstream::binary); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_raw_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +template +inline +bool +diskio::save_raw_binary(const Cube& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + f.write( reinterpret_cast(x.mem), std::streamsize(x.n_elem*sizeof(eT)) ); + + return f.good(); + } + + + +//! Save a cube in text format (human readable), +//! with a header that indicates the cube type as well as its dimensions +template +inline +bool +diskio::save_arma_ascii(const Cube& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str()); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_arma_ascii(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a cube in text format (human readable), +//! with a header that indicates the cube type as well as its dimensions +template +inline +bool +diskio::save_arma_ascii(const Cube& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + const ios::fmtflags orig_flags = f.flags(); + + f << diskio::gen_txt_header(x) << '\n'; + f << x.n_rows << ' ' << x.n_cols << ' ' << x.n_slices << '\n'; + + uword cell_width; + + // TODO: need sane values for complex numbers + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.setf(ios::scientific); + f.precision(10); + cell_width = 18; + } + + for(uword slice=0; slice < x.n_slices; ++slice) + { + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f.put(' '); + + if( (is_float::value == true) || (is_double::value == true) ) + { + f.width(cell_width); + } + + f << x.at(row,col,slice); + } + + f.put('\n'); + } + } + + const bool save_okay = f.good(); + + f.flags(orig_flags); + + return save_okay; + } + + + +//! Save a cube in binary format, +//! with a header that stores the cube type as well as its dimensions +template +inline +bool +diskio::save_arma_binary(const Cube& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f(tmp_name.c_str(), std::fstream::binary); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_arma_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +//! Save a cube in binary format, +//! with a header that stores the cube type as well as its dimensions +template +inline +bool +diskio::save_arma_binary(const Cube& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + f << diskio::gen_bin_header(x) << '\n'; + f << x.n_rows << ' ' << x.n_cols << ' ' << x.n_slices << '\n'; + + f.write( reinterpret_cast(x.mem), std::streamsize(x.n_elem*sizeof(eT)) ); + + return f.good(); + } + + + +//! Load a cube as raw text (no header, human readable). +//! NOTE: this is much slower than reading a file with a header. +template +inline +bool +diskio::load_raw_ascii(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + Mat tmp; + const bool load_okay = diskio::load_raw_ascii(tmp, name, err_msg); + + if(load_okay == true) + { + if(tmp.is_empty() == false) + { + x.set_size(tmp.n_rows, tmp.n_cols, 1); + + x.slice(0) = tmp; + } + else + { + x.reset(); + } + } + + return load_okay; + } + + + +//! Load a cube as raw text (no header, human readable). +//! NOTE: this is much slower than reading a file with a header. +template +inline +bool +diskio::load_raw_ascii(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + Mat tmp; + const bool load_okay = diskio::load_raw_ascii(tmp, f, err_msg); + + if(load_okay == true) + { + if(tmp.is_empty() == false) + { + x.set_size(tmp.n_rows, tmp.n_cols, 1); + + x.slice(0) = tmp; + } + else + { + x.reset(); + } + } + + return load_okay; + } + + + +//! Load a cube in binary format (no header); +//! the cube is assumed to have one slice with one column +template +inline +bool +diskio::load_raw_binary(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f; + f.open(name.c_str(), std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_raw_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_raw_binary(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + arma_ignore(err_msg); + + f.clear(); + const std::streampos pos1 = f.tellg(); + + f.clear(); + f.seekg(0, ios::end); + + f.clear(); + const std::streampos pos2 = f.tellg(); + + const uword N = ( (pos1 >= 0) && (pos2 >= 0) ) ? uword(pos2 - pos1) : 0; + + f.clear(); + //f.seekg(0, ios::beg); + f.seekg(pos1); + + x.set_size(N / sizeof(eT), 1, 1); + + f.clear(); + f.read( reinterpret_cast(x.memptr()), std::streamsize(N) ); + + return f.good(); + } + + + +//! Load a cube in text format (human readable), +//! with a header that indicates the cube type as well as its dimensions +template +inline +bool +diskio::load_arma_ascii(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f(name.c_str()); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_arma_ascii(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Load a cube in text format (human readable), +//! with a header that indicates the cube type as well as its dimensions +template +inline +bool +diskio::load_arma_ascii(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + std::string f_header; + uword f_n_rows; + uword f_n_cols; + uword f_n_slices; + + f >> f_header; + f >> f_n_rows; + f >> f_n_cols; + f >> f_n_slices; + + if(f_header == diskio::gen_txt_header(x)) + { + x.set_size(f_n_rows, f_n_cols, f_n_slices); + + for(uword slice=0; slice < x.n_slices; ++slice) + { + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f >> x.at(row,col,slice); + } + } + } + + load_okay = f.good(); + } + else + { + load_okay = false; + err_msg = "incorrect header in "; + } + + return load_okay; + } + + + +//! Load a cube in binary format, +//! with a header that indicates the cube type as well as its dimensions +template +inline +bool +diskio::load_arma_binary(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f; + f.open(name.c_str(), std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_arma_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_arma_binary(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + std::string f_header; + uword f_n_rows; + uword f_n_cols; + uword f_n_slices; + + f >> f_header; + f >> f_n_rows; + f >> f_n_cols; + f >> f_n_slices; + + if(f_header == diskio::gen_bin_header(x)) + { + //f.seekg(1, ios::cur); // NOTE: this may not be portable, as on a Windows machine a newline could be two characters + f.get(); + + x.set_size(f_n_rows, f_n_cols, f_n_slices); + f.read( reinterpret_cast(x.memptr()), std::streamsize(x.n_elem*sizeof(eT)) ); + + load_okay = f.good(); + } + else + { + load_okay = false; + err_msg = "incorrect header in "; + } + + return load_okay; + } + + + +//! Try to load a cube by automatically determining its type +template +inline +bool +diskio::load_auto_detect(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_auto_detect(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Try to load a cube by automatically determining its type +template +inline +bool +diskio::load_auto_detect(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + static const std::string ARMA_CUB_TXT = "ARMA_CUB_TXT"; + static const std::string ARMA_CUB_BIN = "ARMA_CUB_BIN"; + static const std::string P6 = "P6"; + + podarray raw_header(ARMA_CUB_TXT.length() + 1); + + std::streampos pos = f.tellg(); + + f.read( raw_header.memptr(), std::streamsize(ARMA_CUB_TXT.length()) ); + raw_header[ARMA_CUB_TXT.length()] = '\0'; + + f.clear(); + f.seekg(pos); + + const std::string header = raw_header.mem; + + if(ARMA_CUB_TXT == header.substr(0, ARMA_CUB_TXT.length())) + { + return load_arma_ascii(x, f, err_msg); + } + else + if(ARMA_CUB_BIN == header.substr(0, ARMA_CUB_BIN.length())) + { + return load_arma_binary(x, f, err_msg); + } + else + if(P6 == header.substr(0, P6.length())) + { + return load_ppm_binary(x, f, err_msg); + } + else + { + const file_type ft = guess_file_type(f); + + switch(ft) + { + // case csv_ascii: + // return load_csv_ascii(x, f, err_msg); + // break; + + case raw_binary: + return load_raw_binary(x, f, err_msg); + break; + + case raw_ascii: + return load_raw_ascii(x, f, err_msg); + break; + + default: + err_msg = "unknown data in "; + return false; + } + } + + return false; + } + + + + + +// fields + + + +template +inline +bool +diskio::save_arma_binary(const field& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f( tmp_name.c_str(), std::fstream::binary ); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_arma_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +template +inline +bool +diskio::save_arma_binary(const field& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + arma_type_check(( (is_Mat::value == false) && (is_Cube::value == false) )); + + f << "ARMA_FLD_BIN" << '\n'; + f << x.n_rows << '\n'; + f << x.n_cols << '\n'; + + bool save_okay = true; + + for(uword i=0; i +inline +bool +diskio::load_arma_binary(field& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f( name.c_str(), std::fstream::binary ); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_arma_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_arma_binary(field& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_type_check(( (is_Mat::value == false) && (is_Cube::value == false) )); + + bool load_okay = true; + + std::string f_type; + f >> f_type; + + if(f_type != "ARMA_FLD_BIN") + { + load_okay = false; + err_msg = "unsupported field type in "; + } + else + { + uword f_n_rows; + uword f_n_cols; + + f >> f_n_rows; + f >> f_n_cols; + + x.set_size(f_n_rows, f_n_cols); + + f.get(); + + for(uword i=0; i& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f( tmp_name.c_str(), std::fstream::binary ); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_std_string(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +inline +bool +diskio::save_std_string(const field& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + for(uword row=0; row& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::ifstream f( name.c_str() ); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_std_string(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +inline +bool +diskio::load_std_string(field& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + // + // work out the size + + uword f_n_rows = 0; + uword f_n_cols = 0; + + bool f_n_cols_found = false; + + std::string line_string; + std::string token; + + while( (f.good() == true) && (load_okay == true) ) + { + std::getline(f, line_string); + if(line_string.size() == 0) + break; + + std::stringstream line_stream(line_string); + + uword line_n_cols = 0; + while (line_stream >> token) + line_n_cols++; + + if(f_n_cols_found == false) + { + f_n_cols = line_n_cols; + f_n_cols_found = true; + } + else + { + if(line_n_cols != f_n_cols) + { + load_okay = false; + err_msg = "inconsistent number of columns in "; + } + } + + ++f_n_rows; + } + + if(load_okay == true) + { + f.clear(); + f.seekg(0, ios::beg); + //f.seekg(start); + + x.set_size(f_n_rows, f_n_cols); + + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + f >> x.at(row,col); + } + } + } + + if(f.good() == false) + { + load_okay = false; + } + + return load_okay; + } + + + +//! Try to load a field by automatically determining its type +template +inline +bool +diskio::load_auto_detect(field& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_auto_detect(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +//! Try to load a field by automatically determining its type +template +inline +bool +diskio::load_auto_detect(field& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_Mat::value == false )); + + static const std::string ARMA_FLD_BIN = "ARMA_FLD_BIN"; + static const std::string P6 = "P6"; + + podarray raw_header(ARMA_FLD_BIN.length() + 1); + + std::streampos pos = f.tellg(); + + f.read( raw_header.memptr(), std::streamsize(ARMA_FLD_BIN.length()) ); + + f.clear(); + f.seekg(pos); + + raw_header[ARMA_FLD_BIN.length()] = '\0'; + + const std::string header = raw_header.mem; + + if(ARMA_FLD_BIN == header.substr(0, ARMA_FLD_BIN.length())) + { + return load_arma_binary(x, f, err_msg); + } + else + if(P6 == header.substr(0, P6.length())) + { + return load_ppm_binary(x, f, err_msg); + } + else + { + err_msg = "unsupported header in "; + return false; + } + } + + + +// +// handling of PPM images by cubes + + +template +inline +bool +diskio::load_ppm_binary(Cube& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_ppm_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_ppm_binary(Cube& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + bool load_okay = true; + + std::string f_header; + f >> f_header; + + if(f_header == "P6") + { + uword f_n_rows = 0; + uword f_n_cols = 0; + int f_maxval = 0; + + diskio::pnm_skip_comments(f); + + f >> f_n_cols; + diskio::pnm_skip_comments(f); + + f >> f_n_rows; + diskio::pnm_skip_comments(f); + + f >> f_maxval; + f.get(); + + if( (f_maxval > 0) || (f_maxval <= 65535) ) + { + x.set_size(f_n_rows, f_n_cols, 3); + + if(f_maxval <= 255) + { + const uword n_elem = 3*f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(n_elem) ); + + uword i = 0; + + //cout << "f_n_cols = " << f_n_cols << endl; + //cout << "f_n_rows = " << f_n_rows << endl; + + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + x.at(row,col,0) = eT(tmp[i+0]); + x.at(row,col,1) = eT(tmp[i+1]); + x.at(row,col,2) = eT(tmp[i+2]); + i+=3; + } + + } + } + else + { + const uword n_elem = 3*f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(2*n_elem) ); + + uword i = 0; + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + x.at(row,col,0) = eT(tmp[i+0]); + x.at(row,col,1) = eT(tmp[i+1]); + x.at(row,col,2) = eT(tmp[i+2]); + i+=3; + } + + } + + } + + } + else + { + load_okay = false; + err_msg = "currently no code available to handle loading "; + } + + if(f.good() == false) + { + load_okay = false; + } + + } + else + { + load_okay = false; + err_msg = "unsupported header in "; + } + + return load_okay; + } + + + +template +inline +bool +diskio::save_ppm_binary(const Cube& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + + std::ofstream f( tmp_name.c_str(), std::fstream::binary ); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_ppm_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +template +inline +bool +diskio::save_ppm_binary(const Cube& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (x.n_slices != 3), "diskio::save_ppm_binary(): given cube must have exactly 3 slices" ); + + const uword n_elem = 3 * x.n_rows * x.n_cols; + podarray tmp(n_elem); + + uword i = 0; + for(uword row=0; row < x.n_rows; ++row) + { + for(uword col=0; col < x.n_cols; ++col) + { + tmp[i+0] = u8( access::tmp_real( x.at(row,col,0) ) ); + tmp[i+1] = u8( access::tmp_real( x.at(row,col,1) ) ); + tmp[i+2] = u8( access::tmp_real( x.at(row,col,2) ) ); + + i+=3; + } + } + + f << "P6" << '\n'; + f << x.n_cols << '\n'; + f << x.n_rows << '\n'; + f << 255 << '\n'; + + f.write( reinterpret_cast(tmp.mem), std::streamsize(n_elem) ); + + return f.good(); + } + + + +// +// handling of PPM images by fields + + + +template +inline +bool +diskio::load_ppm_binary(field& x, const std::string& name, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + std::fstream f; + f.open(name.c_str(), std::fstream::in | std::fstream::binary); + + bool load_okay = f.is_open(); + + if(load_okay == true) + { + load_okay = diskio::load_ppm_binary(x, f, err_msg); + f.close(); + } + + return load_okay; + } + + + +template +inline +bool +diskio::load_ppm_binary(field& x, std::istream& f, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_Mat::value == false )); + typedef typename T1::elem_type eT; + + bool load_okay = true; + + std::string f_header; + f >> f_header; + + if(f_header == "P6") + { + uword f_n_rows = 0; + uword f_n_cols = 0; + int f_maxval = 0; + + diskio::pnm_skip_comments(f); + + f >> f_n_cols; + diskio::pnm_skip_comments(f); + + f >> f_n_rows; + diskio::pnm_skip_comments(f); + + f >> f_maxval; + f.get(); + + if( (f_maxval > 0) || (f_maxval <= 65535) ) + { + x.set_size(3); + Mat& R = x(0); + Mat& G = x(1); + Mat& B = x(2); + + R.set_size(f_n_rows,f_n_cols); + G.set_size(f_n_rows,f_n_cols); + B.set_size(f_n_rows,f_n_cols); + + if(f_maxval <= 255) + { + const uword n_elem = 3*f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(n_elem) ); + + uword i = 0; + + //cout << "f_n_cols = " << f_n_cols << endl; + //cout << "f_n_rows = " << f_n_rows << endl; + + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + R.at(row,col) = eT(tmp[i+0]); + G.at(row,col) = eT(tmp[i+1]); + B.at(row,col) = eT(tmp[i+2]); + i+=3; + } + + } + } + else + { + const uword n_elem = 3*f_n_cols*f_n_rows; + podarray tmp(n_elem); + + f.read( reinterpret_cast(tmp.memptr()), std::streamsize(2*n_elem) ); + + uword i = 0; + + for(uword row=0; row < f_n_rows; ++row) + { + for(uword col=0; col < f_n_cols; ++col) + { + R.at(row,col) = eT(tmp[i+0]); + G.at(row,col) = eT(tmp[i+1]); + B.at(row,col) = eT(tmp[i+2]); + i+=3; + } + + } + + } + + } + else + { + load_okay = false; + err_msg = "currently no code available to handle loading "; + } + + if(f.good() == false) + { + load_okay = false; + } + + } + else + { + load_okay = false; + err_msg = "unsupported header in "; + } + + return load_okay; + } + + + +template +inline +bool +diskio::save_ppm_binary(const field& x, const std::string& final_name) + { + arma_extra_debug_sigprint(); + + const std::string tmp_name = diskio::gen_tmp_name(final_name); + std::ofstream f( tmp_name.c_str(), std::fstream::binary ); + + bool save_okay = f.is_open(); + + if(save_okay == true) + { + save_okay = diskio::save_ppm_binary(x, f); + + f.flush(); + f.close(); + + if(save_okay == true) + { + save_okay = diskio::safe_rename(tmp_name, final_name); + } + } + + return save_okay; + } + + + +template +inline +bool +diskio::save_ppm_binary(const field& x, std::ostream& f) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_Mat::value == false )); + + typedef typename T1::elem_type eT; + + arma_debug_check( (x.n_elem != 3), "diskio::save_ppm_binary(): given field must have exactly 3 matrices of equal size" ); + + bool same_size = true; + for(uword i=1; i<3; ++i) + { + if( (x(0).n_rows != x(i).n_rows) || (x(0).n_cols != x(i).n_cols) ) + { + same_size = false; + break; + } + } + + arma_debug_check( (same_size != true), "diskio::save_ppm_binary(): given field must have exactly 3 matrices of equal size" ); + + const Mat& R = x(0); + const Mat& G = x(1); + const Mat& B = x(2); + + f << "P6" << '\n'; + f << R.n_cols << '\n'; + f << R.n_rows << '\n'; + f << 255 << '\n'; + + const uword n_elem = 3 * R.n_rows * R.n_cols; + podarray tmp(n_elem); + + uword i = 0; + for(uword row=0; row < R.n_rows; ++row) + { + for(uword col=0; col < R.n_cols; ++col) + { + tmp[i+0] = u8( access::tmp_real( R.at(row,col) ) ); + tmp[i+1] = u8( access::tmp_real( G.at(row,col) ) ); + tmp[i+2] = u8( access::tmp_real( B.at(row,col) ) ); + + i+=3; + } + } + + f.write( reinterpret_cast(tmp.mem), std::streamsize(n_elem) ); + + return f.good(); + } + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eGlueCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eGlueCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,47 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eGlueCube +//! @{ + + +template +class eGlueCube : public BaseCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + static const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + static const bool has_subview = (ProxyCube::has_subview || ProxyCube::has_subview ); + + arma_aligned const ProxyCube P1; + arma_aligned const ProxyCube P2; + + arma_inline ~eGlueCube(); + arma_inline eGlueCube(const T1& in_A, const T2& in_B); + + arma_inline uword get_n_rows() const; + arma_inline uword get_n_cols() const; + arma_inline uword get_n_elem_slice() const; + arma_inline uword get_n_slices() const; + arma_inline uword get_n_elem() const; + + arma_inline elem_type operator[] (const uword i) const; + arma_inline elem_type at (const uword row, const uword col, const uword slice) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eGlueCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eGlueCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,129 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eGlueCube +//! @{ + + + +template +arma_inline +eGlueCube::~eGlueCube() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +eGlueCube::eGlueCube(const T1& in_A, const T2& in_B) + : P1(in_A) + , P2(in_B) + { + arma_extra_debug_sigprint(); + + arma_assert_same_size + ( + P1.get_n_rows(), P1.get_n_cols(), P1.get_n_slices(), + P2.get_n_rows(), P2.get_n_cols(), P2.get_n_slices(), + eglue_type::text() + ); + } + + + +template +arma_inline +uword +eGlueCube::get_n_rows() const + { + return P1.get_n_rows(); + } + + + +template +arma_inline +uword +eGlueCube::get_n_cols() const + { + return P1.get_n_cols(); + } + + + +template +arma_inline +uword +eGlueCube::get_n_slices() const + { + return P1.get_n_slices(); + } + + + +template +arma_inline +uword +eGlueCube::get_n_elem_slice() const + { + return P1.get_n_elem_slice(); + } + + + +template +arma_inline +uword +eGlueCube::get_n_elem() const + { + return P1.get_n_elem(); + } + + + +template +arma_inline +typename T1::elem_type +eGlueCube::operator[] (const uword i) const + { + typedef typename T1::elem_type eT; + + // the optimiser will keep only one return statement + + if(is_same_type::value == true) { return P1[i] + P2[i]; } + else if(is_same_type::value == true) { return P1[i] - P2[i]; } + else if(is_same_type::value == true) { return P1[i] / P2[i]; } + else if(is_same_type::value == true) { return P1[i] * P2[i]; } + } + + +template +arma_inline +typename T1::elem_type +eGlueCube::at(const uword row, const uword col, const uword slice) const + { + typedef typename T1::elem_type eT; + + // the optimiser will keep only one return statement + + if(is_same_type::value == true) { return P1.at(row,col,slice) + P2.at(row,col,slice); } + else if(is_same_type::value == true) { return P1.at(row,col,slice) - P2.at(row,col,slice); } + else if(is_same_type::value == true) { return P1.at(row,col,slice) / P2.at(row,col,slice); } + else if(is_same_type::value == true) { return P1.at(row,col,slice) * P2.at(row,col,slice); } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eGlue_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eGlue_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,45 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eGlue +//! @{ + + +template +class eGlue : public Base > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + static const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + static const bool has_subview = (Proxy::has_subview || Proxy::has_subview ); + + arma_aligned const Proxy P1; + arma_aligned const Proxy P2; + + arma_inline ~eGlue(); + arma_inline eGlue(const T1& in_A, const T2& in_B); + + arma_inline uword get_n_rows() const; + arma_inline uword get_n_cols() const; + arma_inline uword get_n_elem() const; + + arma_inline elem_type operator[] (const uword i) const; + arma_inline elem_type at (const uword row, const uword col) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eGlue_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eGlue_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,111 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eGlue +//! @{ + + + +template +arma_inline +eGlue::~eGlue() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +eGlue::eGlue(const T1& in_A, const T2& in_B) + : P1(in_A) + , P2(in_B) + { + arma_extra_debug_sigprint(); + + // arma_debug_assert_same_size( P1, P2, eglue_type::text() ); + arma_debug_assert_same_size + ( + P1.get_n_rows(), P1.get_n_cols(), + P2.get_n_rows(), P2.get_n_cols(), + eglue_type::text() + ); + } + + + +template +arma_inline +uword +eGlue::get_n_rows() const + { + return P1.get_n_rows(); + } + + + +template +arma_inline +uword +eGlue::get_n_cols() const + { + return P1.get_n_cols(); + } + + + +template +arma_inline +uword +eGlue::get_n_elem() const + { + return P1.get_n_elem(); + } + + + +template +arma_inline +typename T1::elem_type +eGlue::operator[] (const uword i) const + { + typedef typename T1::elem_type eT; + + // the optimiser will keep only one return statement + + if(is_same_type::value == true) { return P1[i] + P2[i]; } + else if(is_same_type::value == true) { return P1[i] - P2[i]; } + else if(is_same_type::value == true) { return P1[i] / P2[i]; } + else if(is_same_type::value == true) { return P1[i] * P2[i]; } + } + + +template +arma_inline +typename T1::elem_type +eGlue::at(const uword row, const uword col) const + { + typedef typename T1::elem_type eT; + + // the optimiser will keep only one return statement + + if(is_same_type::value == true) { return P1.at(row,col) + P2.at(row,col); } + else if(is_same_type::value == true) { return P1.at(row,col) - P2.at(row,col); } + else if(is_same_type::value == true) { return P1.at(row,col) / P2.at(row,col); } + else if(is_same_type::value == true) { return P1.at(row,col) * P2.at(row,col); } + } + + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eOpCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eOpCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,55 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eOpCube +//! @{ + + + +template +class eOpCube : public BaseCube > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + + static const bool prefer_at_accessor = ProxyCube::prefer_at_accessor; + static const bool has_subview = ProxyCube::has_subview; + + arma_aligned const ProxyCube P; + arma_aligned elem_type aux; //!< storage of auxiliary data, user defined format + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_c; //!< storage of auxiliary data, uword format + + inline ~eOpCube(); + inline explicit eOpCube(const BaseCube& in_m); + inline eOpCube(const BaseCube& in_m, const elem_type in_aux); + inline eOpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline eOpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + inline eOpCube(const BaseCube& in_m, const elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + + arma_inline uword get_n_rows() const; + arma_inline uword get_n_cols() const; + arma_inline uword get_n_elem_slice() const; + arma_inline uword get_n_slices() const; + arma_inline uword get_n_elem() const; + + arma_inline elem_type operator[] (const uword i) const; + arma_inline elem_type at (const uword row, const uword col, const uword slice) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eOpCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eOpCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,154 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eOpCube +//! @{ + + + +template +eOpCube::eOpCube(const BaseCube& in_m) + : P (in_m.get_ref()) + { + arma_extra_debug_sigprint(); + } + + + +template +eOpCube::eOpCube(const BaseCube& in_m, const typename T1::elem_type in_aux) + : P (in_m.get_ref()) + , aux (in_aux) + { + arma_extra_debug_sigprint(); + } + + + +template +eOpCube::eOpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b) + : P (in_m.get_ref()) + , aux_uword_a (in_aux_uword_a) + , aux_uword_b (in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +eOpCube::eOpCube(const BaseCube& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : P (in_m.get_ref()) + , aux_uword_a (in_aux_uword_a) + , aux_uword_b (in_aux_uword_b) + , aux_uword_c (in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +eOpCube::eOpCube(const BaseCube& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : P (in_m.get_ref()) + , aux (in_aux) + , aux_uword_a (in_aux_uword_a) + , aux_uword_b (in_aux_uword_b) + , aux_uword_c (in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +eOpCube::~eOpCube() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +uword +eOpCube::get_n_rows() const + { + return P.get_n_rows(); + } + + + +template +arma_inline +uword +eOpCube::get_n_cols() const + { + return P.get_n_cols(); + } + + + +template +arma_inline +uword +eOpCube::get_n_elem_slice() const + { + return P.get_n_elem_slice(); + } + + + +template +arma_inline +uword +eOpCube::get_n_slices() const + { + return P.get_n_slices(); + } + + + +template +arma_inline +uword +eOpCube::get_n_elem() const + { + return P.get_n_elem(); + } + + + +template +arma_inline +typename T1::elem_type +eOpCube::operator[] (const uword i) const + { + return eop_core::process(P[i], aux); + } + + + +template +arma_inline +typename T1::elem_type +eOpCube::at(const uword row, const uword col, const uword slice) const + { + typedef typename T1::elem_type eT; + + return eop_core::process(P.at(row, col, slice), aux); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eOp_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eOp_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,52 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eOp +//! @{ + + + +template +class eOp : public Base > + { + public: + + typedef typename T1::elem_type elem_type; + typedef typename get_pod_type::result pod_type; + typedef Proxy proxy_type; + + static const bool prefer_at_accessor = Proxy::prefer_at_accessor; + static const bool has_subview = Proxy::has_subview; + + arma_aligned const Proxy P; + arma_aligned elem_type aux; //!< storage of auxiliary data, user defined format + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + + inline ~eOp(); + inline explicit eOp(const Base& in_m); + inline eOp(const Base& in_m, const elem_type in_aux); + inline eOp(const Base& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline eOp(const Base& in_m, const elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b); + + arma_inline uword get_n_rows() const; + arma_inline uword get_n_cols() const; + arma_inline uword get_n_elem() const; + + arma_inline elem_type operator[] (const uword i) const; + arma_inline elem_type at (const uword row, const uword col) const; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eOp_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eOp_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,119 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eOp +//! @{ + + + +template +eOp::eOp(const Base& in_m) + : P(in_m.get_ref()) + { + arma_extra_debug_sigprint(); + } + + + +template +eOp::eOp(const Base& in_m, const typename T1::elem_type in_aux) + : P(in_m.get_ref()) + , aux(in_aux) + { + arma_extra_debug_sigprint(); + } + + + +template +eOp::eOp(const Base& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b) + : P(in_m.get_ref()) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +eOp::eOp(const Base& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b) + : P(in_m.get_ref()) + , aux(in_aux) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +eOp::~eOp() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +uword +eOp::get_n_rows() const + { + return P.get_n_rows(); + } + + + +template +arma_inline +uword +eOp::get_n_cols() const + { + return P.get_n_cols(); + } + + + +template +arma_inline +uword +eOp::get_n_elem() const + { + return P.get_n_elem(); + } + + + +template +arma_inline +typename T1::elem_type +eOp::operator[] (const uword i) const + { + return eop_core::process(P[i], aux); + } + + + +template +arma_inline +typename T1::elem_type +eOp::at(const uword row, const uword col) const + { + return eop_core::process(P.at(row, col), aux); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eglue_core_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eglue_core_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,52 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eglue_core +//! @{ + + + +template +struct eglue_core + { + + // matrices + + template arma_hot inline static void apply(Mat& out, const eGlue& x); + + template arma_hot inline static void apply_inplace_plus (Mat& out, const eGlue& x); + template arma_hot inline static void apply_inplace_minus(Mat& out, const eGlue& x); + template arma_hot inline static void apply_inplace_schur(Mat& out, const eGlue& x); + template arma_hot inline static void apply_inplace_div (Mat& out, const eGlue& x); + + + // cubes + + template arma_hot inline static void apply(Cube& out, const eGlueCube& x); + + template arma_hot inline static void apply_inplace_plus (Cube& out, const eGlueCube& x); + template arma_hot inline static void apply_inplace_minus(Cube& out, const eGlueCube& x); + template arma_hot inline static void apply_inplace_schur(Cube& out, const eGlueCube& x); + template arma_hot inline static void apply_inplace_div (Cube& out, const eGlueCube& x); + }; + + + +class eglue_plus; +class eglue_minus; +class eglue_div; +class eglue_schur; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eglue_core_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eglue_core_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,632 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eglue_core +//! @{ + + + +class eglue_plus : public eglue_core + { + public: + + inline static const char* text() { return "addition"; } + }; + + + +class eglue_minus : public eglue_core + { + public: + + inline static const char* text() { return "subtraction"; } + }; + + + +class eglue_div : public eglue_core + { + public: + + inline static const char* text() { return "element-wise division"; } + }; + + + +class eglue_schur : public eglue_core + { + public: + + inline static const char* text() { return "element-wise multiplication"; } + }; + + + +#undef arma_applier_1 +#undef arma_applier_2 +#undef arma_applier_3 +#undef operatorA +#undef operatorB + +#define arma_applier_1(operatorA, operatorB) \ + {\ + uword i,j;\ + \ + for(i=0, j=1; j +template +arma_hot +inline +void +eglue_core::apply(Mat& out, const eGlue& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + + // NOTE: we're assuming that the matrix has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Mat contructor or operator=() + + eT* out_mem = out.memptr(); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename Proxy::ea_type P1 = x.P1.get_ea(); + typename Proxy::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(=, +); } + else if(is_same_type::value == true) { arma_applier_1(=, -); } + else if(is_same_type::value == true) { arma_applier_1(=, /); } + else if(is_same_type::value == true) { arma_applier_1(=, *); } + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + const Proxy& P1 = x.P1; + const Proxy& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_2(=, +); } + else if(is_same_type::value == true) { arma_applier_2(=, -); } + else if(is_same_type::value == true) { arma_applier_2(=, /); } + else if(is_same_type::value == true) { arma_applier_2(=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_plus(Mat& out, const eGlue& x) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, x.P1, "addition"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename Proxy::ea_type P1 = x.P1.get_ea(); + typename Proxy::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(+=, +); } + else if(is_same_type::value == true) { arma_applier_1(+=, -); } + else if(is_same_type::value == true) { arma_applier_1(+=, /); } + else if(is_same_type::value == true) { arma_applier_1(+=, *); } + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + const Proxy& P1 = x.P1; + const Proxy& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_2(+=, +); } + else if(is_same_type::value == true) { arma_applier_2(+=, -); } + else if(is_same_type::value == true) { arma_applier_2(+=, /); } + else if(is_same_type::value == true) { arma_applier_2(+=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_minus(Mat& out, const eGlue& x) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, x.P1, "subtraction"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename Proxy::ea_type P1 = x.P1.get_ea(); + typename Proxy::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(-=, +); } + else if(is_same_type::value == true) { arma_applier_1(-=, -); } + else if(is_same_type::value == true) { arma_applier_1(-=, /); } + else if(is_same_type::value == true) { arma_applier_1(-=, *); } + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + const Proxy& P1 = x.P1; + const Proxy& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_2(-=, +); } + else if(is_same_type::value == true) { arma_applier_2(-=, -); } + else if(is_same_type::value == true) { arma_applier_2(-=, /); } + else if(is_same_type::value == true) { arma_applier_2(-=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_schur(Mat& out, const eGlue& x) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, x.P1, "element-wise multiplication"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename Proxy::ea_type P1 = x.P1.get_ea(); + typename Proxy::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(*=, +); } + else if(is_same_type::value == true) { arma_applier_1(*=, -); } + else if(is_same_type::value == true) { arma_applier_1(*=, /); } + else if(is_same_type::value == true) { arma_applier_1(*=, *); } + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + const Proxy& P1 = x.P1; + const Proxy& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_2(*=, +); } + else if(is_same_type::value == true) { arma_applier_2(*=, -); } + else if(is_same_type::value == true) { arma_applier_2(*=, /); } + else if(is_same_type::value == true) { arma_applier_2(*=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_div(Mat& out, const eGlue& x) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, x.P1, "element-wise division"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename Proxy::ea_type P1 = x.P1.get_ea(); + typename Proxy::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(/=, +); } + else if(is_same_type::value == true) { arma_applier_1(/=, -); } + else if(is_same_type::value == true) { arma_applier_1(/=, /); } + else if(is_same_type::value == true) { arma_applier_1(/=, *); } + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + const Proxy& P1 = x.P1; + const Proxy& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_2(*=, +); } + else if(is_same_type::value == true) { arma_applier_2(*=, -); } + else if(is_same_type::value == true) { arma_applier_2(*=, /); } + else if(is_same_type::value == true) { arma_applier_2(*=, *); } + } + } + + + +// +// cubes + + + +template +template +arma_hot +inline +void +eglue_core::apply(Cube& out, const eGlueCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + + // NOTE: we're assuming that the cube has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Cube contructor or operator=() + + + eT* out_mem = out.memptr(); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename ProxyCube::ea_type P1 = x.P1.get_ea(); + typename ProxyCube::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(=, +); } + else if(is_same_type::value == true) { arma_applier_1(=, -); } + else if(is_same_type::value == true) { arma_applier_1(=, /); } + else if(is_same_type::value == true) { arma_applier_1(=, *); } + } + else + { + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + const ProxyCube& P1 = x.P1; + const ProxyCube& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_3(=, +); } + else if(is_same_type::value == true) { arma_applier_3(=, -); } + else if(is_same_type::value == true) { arma_applier_3(=, /); } + else if(is_same_type::value == true) { arma_applier_3(=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_plus(Cube& out, const eGlueCube& x) + { + arma_extra_debug_sigprint(); + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "addition"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename ProxyCube::ea_type P1 = x.P1.get_ea(); + typename ProxyCube::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(+=, +); } + else if(is_same_type::value == true) { arma_applier_1(+=, -); } + else if(is_same_type::value == true) { arma_applier_1(+=, /); } + else if(is_same_type::value == true) { arma_applier_1(+=, *); } + } + else + { + const ProxyCube& P1 = x.P1; + const ProxyCube& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_3(+=, +); } + else if(is_same_type::value == true) { arma_applier_3(+=, -); } + else if(is_same_type::value == true) { arma_applier_3(+=, /); } + else if(is_same_type::value == true) { arma_applier_3(+=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_minus(Cube& out, const eGlueCube& x) + { + arma_extra_debug_sigprint(); + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "subtraction"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename ProxyCube::ea_type P1 = x.P1.get_ea(); + typename ProxyCube::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(-=, +); } + else if(is_same_type::value == true) { arma_applier_1(-=, -); } + else if(is_same_type::value == true) { arma_applier_1(-=, /); } + else if(is_same_type::value == true) { arma_applier_1(-=, *); } + } + else + { + const ProxyCube& P1 = x.P1; + const ProxyCube& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_3(-=, +); } + else if(is_same_type::value == true) { arma_applier_3(-=, -); } + else if(is_same_type::value == true) { arma_applier_3(-=, /); } + else if(is_same_type::value == true) { arma_applier_3(-=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_schur(Cube& out, const eGlueCube& x) + { + arma_extra_debug_sigprint(); + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise multiplication"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename ProxyCube::ea_type P1 = x.P1.get_ea(); + typename ProxyCube::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(*=, +); } + else if(is_same_type::value == true) { arma_applier_1(*=, -); } + else if(is_same_type::value == true) { arma_applier_1(*=, /); } + else if(is_same_type::value == true) { arma_applier_1(*=, *); } + } + else + { + const ProxyCube& P1 = x.P1; + const ProxyCube& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_3(*=, +); } + else if(is_same_type::value == true) { arma_applier_3(*=, -); } + else if(is_same_type::value == true) { arma_applier_3(*=, /); } + else if(is_same_type::value == true) { arma_applier_3(*=, *); } + } + } + + + +template +template +arma_hot +inline +void +eglue_core::apply_inplace_div(Cube& out, const eGlueCube& x) + { + arma_extra_debug_sigprint(); + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise division"); + + typedef typename T1::elem_type eT; + + eT* out_mem = out.memptr(); + + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const uword n_elem = out.n_elem; + + typename ProxyCube::ea_type P1 = x.P1.get_ea(); + typename ProxyCube::ea_type P2 = x.P2.get_ea(); + + if(is_same_type::value == true) { arma_applier_1(/=, +); } + else if(is_same_type::value == true) { arma_applier_1(/=, -); } + else if(is_same_type::value == true) { arma_applier_1(/=, /); } + else if(is_same_type::value == true) { arma_applier_1(/=, *); } + } + else + { + const ProxyCube& P1 = x.P1; + const ProxyCube& P2 = x.P2; + + if(is_same_type::value == true) { arma_applier_3(/=, +); } + else if(is_same_type::value == true) { arma_applier_3(/=, -); } + else if(is_same_type::value == true) { arma_applier_3(/=, /); } + else if(is_same_type::value == true) { arma_applier_3(/=, *); } + } + } + + + +#undef arma_applier_1 +#undef arma_applier_2 +#undef arma_applier_3 + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eop_aux.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eop_aux.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,335 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eop_aux +//! @{ + + + +template +struct eop_aux_randu + { + arma_inline + operator eT () + { + return eT(std::rand()) / eT(RAND_MAX); + } + }; + + + +template +struct eop_aux_randu< std::complex > + { + arma_inline + operator std::complex () + { + return std::complex( T(eop_aux_randu()), T(eop_aux_randu()) ); + } + }; + + + +template +struct eop_aux_randn + { + // // rudimentary method, based on the central limit theorem + // // http://en.wikipedia.org/wiki/Central_limit_theorem + // inline + // operator eT () const + // { + // const uword N = 12; // N must be >= 12 and an even number + // const uword N2 = N/2; + // + // eT acc = eT(0); + // + // for(uword i=0; i::result eTp; + + eTp tmp1; + eTp tmp2; + eTp w; + + do + { + tmp1 = eTp(2) * eTp(std::rand()) / eTp(RAND_MAX) - eTp(1); + tmp2 = eTp(2) * eTp(std::rand()) / eTp(RAND_MAX) - eTp(1); + w = tmp1*tmp1 + tmp2*tmp2; + } + while ( w >= eTp(1) ); + + return eT( tmp1 * std::sqrt( (eTp(-2) * std::log(w)) / w) ); + } + + + // other methods: + // http://en.wikipedia.org/wiki/Ziggurat_algorithm + // + // Marsaglia and Tsang Ziggurat technique to transform from a uniform to a normal distribution. + // G. Marsaglia, W.W. Tsang. + // "Ziggurat method for generating random variables", + // J. Statistical Software, vol 5, 2000. + // http://www.jstatsoft.org/v05/i08/ + }; + + + +template +struct eop_aux_randn< std::complex > + { + arma_inline + operator std::complex () const + { + return std::complex( T(eop_aux_randn()), T(eop_aux_randn()) ); + } + + }; + + +//! use of the SFINAE approach to work around compiler limitations +//! http://en.wikipedia.org/wiki/SFINAE + +class eop_aux + { + public: + + template arma_inline static typename arma_integral_only::result acos (const eT x) { return eT( std::acos(double(x)) ); } + template arma_inline static typename arma_integral_only::result asin (const eT x) { return eT( std::asin(double(x)) ); } + template arma_inline static typename arma_integral_only::result atan (const eT x) { return eT( std::atan(double(x)) ); } + + template arma_inline static typename arma_float_only::result acos (const eT x) { return std::acos(x); } + template arma_inline static typename arma_float_only::result asin (const eT x) { return std::asin(x); } + template arma_inline static typename arma_float_only::result atan (const eT x) { return std::atan(x); } + + template arma_inline static typename arma_cx_only::result acos (const eT x) { return arma_acos(x); } + template arma_inline static typename arma_cx_only::result asin (const eT x) { return arma_asin(x); } + template arma_inline static typename arma_cx_only::result atan (const eT x) { return arma_atan(x); } + + template arma_inline static typename arma_integral_only::result acosh (const eT x) { return eT( arma_acosh(double(x)) ); } + template arma_inline static typename arma_integral_only::result asinh (const eT x) { return eT( arma_asinh(double(x)) ); } + template arma_inline static typename arma_integral_only::result atanh (const eT x) { return eT( arma_atanh(double(x)) ); } + + template arma_inline static typename arma_float_or_cx_only::result acosh (const eT x) { return arma_acosh(x); } + template arma_inline static typename arma_float_or_cx_only::result asinh (const eT x) { return arma_asinh(x); } + template arma_inline static typename arma_float_or_cx_only::result atanh (const eT x) { return arma_atanh(x); } + + template arma_inline static typename arma_not_cx::result conj(const eT x) { return x; } + template arma_inline static std::complex conj(const std::complex& x) { return std::conj(x); } + + template arma_inline static typename arma_integral_only::result sqrt (const eT x) { return eT( std::sqrt (double(x)) ); } + template arma_inline static typename arma_integral_only::result log10 (const eT x) { return eT( std::log10(double(x)) ); } + template arma_inline static typename arma_integral_only::result log (const eT x) { return eT( std::log (double(x)) ); } + template arma_inline static typename arma_integral_only::result exp (const eT x) { return eT( std::exp (double(x)) ); } + template arma_inline static typename arma_integral_only::result cos (const eT x) { return eT( std::cos (double(x)) ); } + template arma_inline static typename arma_integral_only::result sin (const eT x) { return eT( std::sin (double(x)) ); } + template arma_inline static typename arma_integral_only::result tan (const eT x) { return eT( std::tan (double(x)) ); } + template arma_inline static typename arma_integral_only::result cosh (const eT x) { return eT( std::cosh (double(x)) ); } + template arma_inline static typename arma_integral_only::result sinh (const eT x) { return eT( std::sinh (double(x)) ); } + template arma_inline static typename arma_integral_only::result tanh (const eT x) { return eT( std::tanh (double(x)) ); } + + template arma_inline static typename arma_float_or_cx_only::result sqrt (const eT x) { return std::sqrt (x); } + template arma_inline static typename arma_float_or_cx_only::result log10 (const eT x) { return std::log10(x); } + template arma_inline static typename arma_float_or_cx_only::result log (const eT x) { return std::log (x); } + template arma_inline static typename arma_float_or_cx_only::result exp (const eT x) { return std::exp (x); } + template arma_inline static typename arma_float_or_cx_only::result cos (const eT x) { return std::cos (x); } + template arma_inline static typename arma_float_or_cx_only::result sin (const eT x) { return std::sin (x); } + template arma_inline static typename arma_float_or_cx_only::result tan (const eT x) { return std::tan (x); } + template arma_inline static typename arma_float_or_cx_only::result cosh (const eT x) { return std::cosh (x); } + template arma_inline static typename arma_float_or_cx_only::result sinh (const eT x) { return std::sinh (x); } + template arma_inline static typename arma_float_or_cx_only::result tanh (const eT x) { return std::tanh (x); } + + template arma_inline static typename arma_unsigned_integral_only::result neg (const eT x) { return x; } + template arma_inline static typename arma_signed_only::result neg (const eT x) { return -x; } + + template arma_inline static typename arma_integral_only::result floor(const eT x) { return x; } + template arma_inline static typename arma_float_only::result floor(const eT x) { return std::floor(x); } + template arma_inline static typename arma_cx_only::result floor(const eT& x) { return eT( std::floor(x.real()), std::floor(x.imag()) ); } + + template arma_inline static typename arma_integral_only::result ceil(const eT x) { return x; } + template arma_inline static typename arma_float_only::result ceil(const eT x) { return std::ceil(x); } + template arma_inline static typename arma_cx_only::result ceil(const eT& x) { return eT( std::ceil(x.real()), std::ceil(x.imag()) ); } + + template + arma_inline + static + typename arma_integral_only::result + log2 (const eT x) + { + return eT( std::log(double(x))/ double(0.69314718055994530942) ); + } + + + template + arma_inline + static + typename arma_float_or_cx_only::result + log2 (const eT x) + { + typedef typename get_pod_type::result T; + return std::log(x) / T(0.69314718055994530942); + } + + + template + arma_inline + static + typename arma_integral_only::result + exp10 (const eT x) + { + return eT( std::pow(double(10), double(x)) ); + } + + + template + arma_inline + static + typename + arma_float_or_cx_only::result + exp10 (const eT x) + { + typedef typename get_pod_type::result T; + return std::pow( T(10), x); + } + + + template + arma_inline + static + typename arma_integral_only::result + exp2 (const eT x) + { + return eT( std::pow(double(2), double(x)) ); + } + + + template + arma_inline + static + typename arma_float_or_cx_only::result + exp2 (const eT x) + { + typedef typename get_pod_type::result T; + return std::pow( T(2), x); + } + + + template + arma_inline + static + typename arma_float_or_cx_only::result + pow(const T1 base, const T2 exponent) + { + return std::pow(base, exponent); + } + + + + template + arma_inline + static + typename arma_integral_only::result + pow(const T1 base, const T2 exponent) + { + return T1( std::pow( double(base), double(exponent) ) ); + } + + + + template + arma_inline + static + typename arma_integral_only::result + direct_eps(const eT) + { + return eT(0); + } + + + + template + inline + static + typename arma_float_only::result + direct_eps(const eT x) + { + //arma_extra_debug_sigprint(); + + // acording to IEEE Standard for Floating-Point Arithmetic (IEEE 754) + // the mantissa length for double is 53 bits = std::numeric_limits::digits + // the mantissa length for float is 24 bits = std::numeric_limits::digits + + //return std::pow( std::numeric_limits::radix, (std::floor(std::log10(std::abs(x))/std::log10(std::numeric_limits::radix))-(std::numeric_limits::digits-1)) ); + + const eT radix_eT = eT(std::numeric_limits::radix); + const eT digits_m1_eT = eT(std::numeric_limits::digits - 1); + + // return std::pow( radix_eT, eT(std::floor(std::log10(std::abs(x))/std::log10(radix_eT)) - digits_m1_eT) ); + return eop_aux::pow( radix_eT, eT(std::floor(std::log10(std::abs(x))/std::log10(radix_eT)) - digits_m1_eT) ); + } + + + + template + inline + static + typename arma_float_only::result + direct_eps(const std::complex x) + { + //arma_extra_debug_sigprint(); + + //return std::pow( std::numeric_limits::radix, (std::floor(std::log10(std::abs(x))/std::log10(std::numeric_limits::radix))-(std::numeric_limits::digits-1)) ); + + const T radix_T = T(std::numeric_limits::radix); + const T digits_m1_T = T(std::numeric_limits::digits - 1); + + return std::pow( radix_T, T(std::floor(std::log10(std::abs(x))/std::log10(radix_T)) - digits_m1_T) ); + } + + + + //! work around a bug in GCC 4.4 + template arma_inline static + typename arma_unsigned_integral_only::result arma_abs(const eT x) { return x; } + + template arma_inline static + typename arma_signed_integral_only::result arma_abs(const eT x) { return std::abs(x); } + + template arma_inline static + typename arma_float_only::result arma_abs(const eT x) { return std::abs(x); } + + template arma_inline static + typename arma_float_only::result arma_abs(const std::complex x) { return std::abs(x); } + + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eop_core_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eop_core_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,89 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eop_core +//! @{ + + + +template +class eop_core + { + public: + + // matrices + + template arma_hot inline static void apply(Mat& out, const eOp& x); + + template arma_hot inline static void apply_inplace_plus (Mat& out, const eOp& x); + template arma_hot inline static void apply_inplace_minus(Mat& out, const eOp& x); + template arma_hot inline static void apply_inplace_schur(Mat& out, const eOp& x); + template arma_hot inline static void apply_inplace_div (Mat& out, const eOp& x); + + + // cubes + + template arma_hot inline static void apply(Cube& out, const eOpCube& x); + + template arma_hot inline static void apply_inplace_plus (Cube& out, const eOpCube& x); + template arma_hot inline static void apply_inplace_minus(Cube& out, const eOpCube& x); + template arma_hot inline static void apply_inplace_schur(Cube& out, const eOpCube& x); + template arma_hot inline static void apply_inplace_div (Cube& out, const eOpCube& x); + + + // common + + template arma_hot arma_pure arma_inline static eT process(const eT val, const eT k); + }; + + + +class eop_neg : public eop_core {}; +class eop_scalar_plus : public eop_core {}; +class eop_scalar_minus_pre : public eop_core {}; +class eop_scalar_minus_post : public eop_core {}; +class eop_scalar_times : public eop_core {}; +class eop_scalar_div_pre : public eop_core {}; +class eop_scalar_div_post : public eop_core {}; +class eop_square : public eop_core {}; +class eop_sqrt : public eop_core {}; +class eop_log : public eop_core {}; +class eop_log2 : public eop_core {}; +class eop_log10 : public eop_core {}; +class eop_trunc_log : public eop_core {}; +class eop_exp : public eop_core {}; +class eop_exp2 : public eop_core {}; +class eop_exp10 : public eop_core {}; +class eop_trunc_exp : public eop_core {}; +class eop_cos : public eop_core {}; +class eop_sin : public eop_core {}; +class eop_tan : public eop_core {}; +class eop_acos : public eop_core {}; +class eop_asin : public eop_core {}; +class eop_atan : public eop_core {}; +class eop_cosh : public eop_core {}; +class eop_sinh : public eop_core {}; +class eop_tanh : public eop_core {}; +class eop_acosh : public eop_core {}; +class eop_asinh : public eop_core {}; +class eop_atanh : public eop_core {}; +class eop_eps : public eop_core {}; +class eop_abs : public eop_core {}; +class eop_conj : public eop_core {}; +class eop_pow : public eop_core {}; +class eop_floor : public eop_core {}; +class eop_ceil : public eop_core {}; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/eop_core_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/eop_core_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,629 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup eop_core +//! @{ + + +#undef arma_applier_1 +#undef arma_applier_2 +#undef arma_applier_3 +#undef operatorA + +#define arma_applier_1(operatorA) \ + {\ + uword i,j;\ + \ + for(i=0, j=1; j::process(tmp_i, k);\ + tmp_j = eop_core::process(tmp_j, k);\ + \ + out_mem[i] operatorA tmp_i;\ + out_mem[j] operatorA tmp_j;\ + }\ + \ + if(i < n_elem)\ + {\ + out_mem[i] operatorA eop_core::process(P[i], k);\ + }\ + } + + +#define arma_applier_2(operatorA) \ + {\ + uword count = 0;\ + \ + for(uword col=0; col::process(tmp_i, k);\ + tmp_j = eop_core::process(tmp_j, k);\ + \ + out_mem[count ] operatorA tmp_i;\ + out_mem[count+1] operatorA tmp_j;\ + }\ + \ + if(i < n_rows)\ + {\ + out_mem[count] operatorA eop_core::process(P.at(i,col), k);\ + ++count;\ + }\ + }\ + } + + + +#define arma_applier_3(operatorA) \ + {\ + uword count = 0;\ + \ + for(uword slice=0; slice::process(tmp_i, k);\ + tmp_j = eop_core::process(tmp_j, k);\ + \ + out_mem[count ] operatorA tmp_i;\ + out_mem[count+1] operatorA tmp_j;\ + }\ + \ + if(i < n_rows)\ + {\ + out_mem[count] operatorA eop_core::process(P.at(i,col,slice), k);\ + ++count;\ + }\ + }\ + }\ + } + + + +// +// matrices + + + +template +template +arma_hot +inline +void +eop_core::apply(Mat& out, const eOp& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_elem = out.n_elem; + + // NOTE: we're assuming that the matrix has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Mat contructor or operator=() + + const eT k = x.aux; + eT* out_mem = out.memptr(); + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = x.P.get_ea(); + + arma_applier_1(=); + } + else + { + const Proxy& P = x.P; + + arma_applier_2(=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_plus(Mat& out, const eOp& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "addition"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = x.P.get_ea(); + + arma_applier_1(+=); + } + else + { + const Proxy& P = x.P; + + arma_applier_2(+=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_minus(Mat& out, const eOp& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "subtraction"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = x.P.get_ea(); + + arma_applier_1(-=); + } + else + { + const Proxy& P = x.P; + + arma_applier_2(-=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_schur(Mat& out, const eOp& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "element-wise multiplication"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = x.P.get_ea(); + + arma_applier_1(*=); + } + else + { + const Proxy& P = x.P; + + arma_applier_2(*=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_div(Mat& out, const eOp& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, n_rows, n_cols, "element-wise division"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = x.P.get_ea(); + + arma_applier_1(/=); + } + else + { + const Proxy& P = x.P; + + arma_applier_2(/=); + } + } + + + +// +// cubes + + + +template +template +arma_hot +inline +void +eop_core::apply(Cube& out, const eOpCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_slices = out.n_slices; + const uword n_elem = out.n_elem; + + // NOTE: we're assuming that the matrix has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Mat contructor or operator=() + + const eT k = x.aux; + eT* out_mem = out.memptr(); + + if(ProxyCube::prefer_at_accessor == false) + { + typename ProxyCube::ea_type P = x.P.get_ea(); + + arma_applier_1(=); + } + else + { + const ProxyCube& P = x.P; + + arma_applier_3(=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_plus(Cube& out, const eOpCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "addition"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(ProxyCube::prefer_at_accessor == false) + { + typename ProxyCube::ea_type P = x.P.get_ea(); + + arma_applier_1(+=); + } + else + { + const ProxyCube& P = x.P; + + arma_applier_3(+=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_minus(Cube& out, const eOpCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "subtraction"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(ProxyCube::prefer_at_accessor == false) + { + typename ProxyCube::ea_type P = x.P.get_ea(); + + arma_applier_1(-=); + } + else + { + const ProxyCube& P = x.P; + + arma_applier_3(-=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_schur(Cube& out, const eOpCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise multiplication"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(ProxyCube::prefer_at_accessor == false) + { + typename ProxyCube::ea_type P = x.P.get_ea(); + + arma_applier_1(*=); + } + else + { + const ProxyCube& P = x.P; + + arma_applier_3(*=); + } + } + + + +template +template +arma_hot +inline +void +eop_core::apply_inplace_div(Cube& out, const eOpCube& x) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword n_rows = x.get_n_rows(); + const uword n_cols = x.get_n_cols(); + const uword n_slices = x.get_n_slices(); + + arma_debug_assert_same_size(out.n_rows, out.n_cols, out.n_slices, n_rows, n_cols, n_slices, "element-wise division"); + + eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + const eT k = x.aux; + + if(ProxyCube::prefer_at_accessor == false) + { + typename ProxyCube::ea_type P = x.P.get_ea(); + + arma_applier_1(/=); + } + else + { + const ProxyCube& P = x.P; + + arma_applier_3(/=); + } + } + + + +// +// common + + + +template +template +arma_hot +arma_pure +arma_inline +eT +eop_core::process(const eT val, const eT k) + { + arma_ignore(val); + arma_ignore(k); + + arma_stop("eop_core::process(): unhandled eop_type"); + return eT(0); + } + + + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return val + k; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return k - val; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return val - k; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return val * k; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return k / val; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT k) { return val / k; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT ) { return val*val; } + +template<> template arma_hot arma_const arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::neg(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::sqrt(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::log(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::log2(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::log10(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return arma::trunc_log(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::exp(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::exp2(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::exp10(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return arma::trunc_exp(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::cos(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::sin(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::tan(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::acos(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::asin(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::atan(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::cosh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::sinh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::tanh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::acosh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::asinh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::atanh(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::direct_eps(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::arma_abs(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::conj(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT k) { return eop_aux::pow(val, k); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::floor(val); } + +template<> template arma_hot arma_pure arma_inline eT +eop_core::process(const eT val, const eT ) { return eop_aux::ceil(val); } + + + +#undef arma_applier_1 +#undef arma_applier_2 +#undef arma_applier_3 + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/field_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/field_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,261 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Ian Cullinan +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup field +//! @{ + + + +struct field_prealloc_n_elem + { + static const uword val = 16; + }; + + + +//! A lightweight 2D container for abitrary objects +//! (the objects must have a copy constructor) + +template +class field + { + public: + + typedef oT object_type; + + const uword n_rows; //!< number of rows in the field (read-only) + const uword n_cols; //!< number of columns in the field (read-only) + const uword n_elem; //!< number of elements in the field (read-only) + + + private: + + arma_aligned oT** mem; //!< pointer to memory used by the object + arma_aligned oT* mem_local[ field_prealloc_n_elem::val ]; + //!< Internal memory, to avoid calling the 'new' operator for small amounts of memory + + + public: + + inline ~field(); + inline field(); + + inline field(const field& x); + inline const field& operator=(const field& x); + + inline field(const subview_field& x); + inline const field& operator=(const subview_field& x); + + inline explicit field(const uword n_elem_in); + inline field(const uword n_rows_in, const uword n_cols_in); + + inline void set_size(const uword n_obj_in); + inline void set_size(const uword n_rows_in, const uword n_cols_in); + + template + inline void copy_size(const field& x); + + arma_inline oT& operator[](const uword i); + arma_inline const oT& operator[](const uword i) const; + + arma_inline oT& at(const uword i); + arma_inline const oT& at(const uword i) const; + + arma_inline oT& operator()(const uword i); + arma_inline const oT& operator()(const uword i) const; + + arma_inline oT& at(const uword row, const uword col); + arma_inline const oT& at(const uword row, const uword col) const; + + arma_inline oT& operator()(const uword row, const uword col); + arma_inline const oT& operator()(const uword row, const uword col) const; + + inline field_injector operator<<(const oT& val); + inline field_injector operator<<(const injector_end_of_row& x); + + + inline subview_field row(const uword row_num); + inline const subview_field row(const uword row_num) const; + + inline subview_field col(const uword col_num); + inline const subview_field col(const uword col_num) const; + + inline subview_field rows(const uword in_row1, const uword in_row2); + inline const subview_field rows(const uword in_row1, const uword in_row2) const; + + inline subview_field cols(const uword in_col1, const uword in_col2); + inline const subview_field cols(const uword in_col1, const uword in_col2) const; + + inline subview_field subfield(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2); + inline const subview_field subfield(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const; + + inline subview_field subfield (const span& row_span, const span& col_span); + inline const subview_field subfield (const span& row_span, const span& col_span) const; + + inline subview_field operator()(const span& row_span, const span& col_span); + inline const subview_field operator()(const span& row_span, const span& col_span) const; + + + inline void print(const std::string extra_text = "") const; + inline void print(std::ostream& user_stream, const std::string extra_text = "") const; + + inline void fill(const oT& x); + + inline void reset(); + inline void reset_objects(); + + arma_inline bool is_empty() const; + + arma_inline arma_warn_unused bool in_range(const uword i) const; + arma_inline arma_warn_unused bool in_range(const span& x) const; + + arma_inline arma_warn_unused bool in_range(const uword in_row, const uword in_col ) const; + arma_inline arma_warn_unused bool in_range(const span& row_span, const uword in_col ) const; + arma_inline arma_warn_unused bool in_range(const uword in_row, const span& col_span) const; + arma_inline arma_warn_unused bool in_range(const span& row_span, const span& col_span) const; + + inline bool save(const std::string name, const file_type type = arma_binary, const bool print_status = true) const; + inline bool save( std::ostream& os, const file_type type = arma_binary, const bool print_status = true) const; + + inline bool load(const std::string name, const file_type type = auto_detect, const bool print_status = true); + inline bool load( std::istream& is, const file_type type = auto_detect, const bool print_status = true); + + + inline bool quiet_save(const std::string name, const file_type type = arma_binary) const; + inline bool quiet_save( std::ostream& os, const file_type type = arma_binary) const; + + inline bool quiet_load(const std::string name, const file_type type = auto_detect); + inline bool quiet_load( std::istream& is, const file_type type = auto_detect); + + + // iterators + + class iterator + { + public: + + inline iterator(field& in_M, const bool at_end = false); + + inline oT& operator* (); + + inline iterator& operator++(); + inline void operator++(int); + + inline iterator& operator--(); + inline void operator--(int); + + inline bool operator!=(const iterator& X) const; + inline bool operator==(const iterator& X) const; + + arma_aligned field& M; + arma_aligned uword i; + }; + + + class const_iterator + { + public: + + const_iterator(const field& in_M, const bool at_end = false); + const_iterator(const iterator& X); + + inline const oT& operator*() const; + + inline const_iterator& operator++(); + inline void operator++(int); + + inline const_iterator& operator--(); + inline void operator--(int); + + inline bool operator!=(const const_iterator& X) const; + inline bool operator==(const const_iterator& X) const; + + arma_aligned const field& M; + arma_aligned uword i; + }; + + inline iterator begin(); + inline const_iterator begin() const; + + inline iterator end(); + inline const_iterator end() const; + + + private: + + inline void init(const field& x); + inline void init(const uword n_rows_in, const uword n_cols_in); + + inline void delete_objects(); + inline void create_objects(); + + friend class field_aux; + friend class subview_field; + + + public: + + #ifdef ARMA_EXTRA_FIELD_PROTO + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_FIELD_PROTO) + #endif + }; + + + +class field_aux + { + public: + + template inline static void reset_objects(field< oT >& x); + template inline static void reset_objects(field< Mat >& x); + template inline static void reset_objects(field< Col >& x); + template inline static void reset_objects(field< Row >& x); + template inline static void reset_objects(field< Cube >& x); + inline static void reset_objects(field< std::string >& x); + + + template inline static bool save(const field< oT >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool save(const field< oT >& x, std::ostream& os, const file_type type, std::string& err_msg); + template inline static bool load( field< oT >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool load( field< oT >& x, std::istream& is, const file_type type, std::string& err_msg); + + template inline static bool save(const field< Mat >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool save(const field< Mat >& x, std::ostream& os, const file_type type, std::string& err_msg); + template inline static bool load( field< Mat >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool load( field< Mat >& x, std::istream& is, const file_type type, std::string& err_msg); + + template inline static bool save(const field< Col >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool save(const field< Col >& x, std::ostream& os, const file_type type, std::string& err_msg); + template inline static bool load( field< Col >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool load( field< Col >& x, std::istream& is, const file_type type, std::string& err_msg); + + template inline static bool save(const field< Row >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool save(const field< Row >& x, std::ostream& os, const file_type type, std::string& err_msg); + template inline static bool load( field< Row >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool load( field< Row >& x, std::istream& is, const file_type type, std::string& err_msg); + + template inline static bool save(const field< Cube >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool save(const field< Cube >& x, std::ostream& os, const file_type type, std::string& err_msg); + template inline static bool load( field< Cube >& x, const std::string& name, const file_type type, std::string& err_msg); + template inline static bool load( field< Cube >& x, std::istream& is, const file_type type, std::string& err_msg); + + inline static bool save(const field< std::string >& x, const std::string& name, const file_type type, std::string& err_msg); + inline static bool save(const field< std::string >& x, std::ostream& os, const file_type type, std::string& err_msg); + inline static bool load( field< std::string >& x, const std::string& name, const file_type type, std::string& err_msg); + inline static bool load( field< std::string >& x, std::istream& is, const file_type type, std::string& err_msg); + + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/field_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/field_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,2008 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Ian Cullinan +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup field +//! @{ + + +template +inline +field::~field() + { + arma_extra_debug_sigprint_this(this); + + delete_objects(); + + if(n_elem > sizeof(mem_local)/sizeof(oT*) ) + { + delete [] mem; + } + + if(arma_config::debug == true) + { + // try to expose buggy user code that accesses deleted objects + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + access::rw(n_elem) = 0; + mem = 0; + } + } + + + +template +inline +field::field() + : n_rows(0) + , n_cols(0) + , n_elem(0) + , mem(0) + { + arma_extra_debug_sigprint_this(this); + } + + + +//! construct a field from a given field +template +inline +field::field(const field& x) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , mem(0) + { + arma_extra_debug_sigprint(arma_boost::format("this = %x x = %x") % this % &x); + + init(x); + } + + + +//! construct a field from a given field +template +inline +const field& +field::operator=(const field& x) + { + arma_extra_debug_sigprint(); + + init(x); + return *this; + } + + + +//! construct a field from subview_field (e.g. construct a field from a delayed subfield operation) +template +inline +field::field(const subview_field& X) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , mem(0) + { + arma_extra_debug_sigprint_this(this); + + this->operator=(X); + } + + + +//! construct a field from subview_field (e.g. construct a field from a delayed subfield operation) +template +inline +const field& +field::operator=(const subview_field& X) + { + arma_extra_debug_sigprint(); + + subview_field::extract(*this, X); + return *this; + } + + + +//! construct the field with the specified number of elements, +//! assuming a column-major layout +template +inline +field::field(const uword n_elem_in) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , mem(0) + { + arma_extra_debug_sigprint_this(this); + + init(n_elem_in, 1); + } + + + +//! construct the field with the specified dimensions +template +inline +field::field(const uword n_rows_in, const uword n_cols_in) + : n_rows(0) + , n_cols(0) + , n_elem(0) + , mem(0) + { + arma_extra_debug_sigprint_this(this); + + init(n_rows_in, n_cols_in); + } + + + +//! change the field to have the specified number of elements, +//! assuming a column-major layout (data is not preserved) +template +inline +void +field::set_size(const uword n_elem_in) + { + arma_extra_debug_sigprint(arma_boost::format("n_elem_in = %d") % n_elem_in); + + init(n_elem_in, 1); + } + + + +//! change the field to have the specified dimensions (data is not preserved) +template +inline +void +field::set_size(const uword n_rows_in, const uword n_cols_in) + { + arma_extra_debug_sigprint(arma_boost::format("n_rows_in = %d, n_cols_in = %d") % n_rows_in % n_cols_in); + + init(n_rows_in, n_cols_in); + } + + + +//! change the field to have the specified dimensions (data is not preserved) +template +template +inline +void +field::copy_size(const field& x) + { + arma_extra_debug_sigprint(); + + init(x.n_rows, x.n_cols); + } + + + +//! linear element accessor (treats the field as a vector); no bounds check +template +arma_inline +oT& +field::operator[] (const uword i) + { + return (*mem[i]); + } + + + +//! linear element accessor (treats the field as a vector); no bounds check +template +arma_inline +const oT& +field::operator[] (const uword i) const + { + return (*mem[i]); + } + + + +//! linear element accessor (treats the field as a vector); no bounds check +template +arma_inline +oT& +field::at(const uword i) + { + return (*mem[i]); + } + + + +//! linear element accessor (treats the field as a vector); no bounds check +template +arma_inline +const oT& +field::at(const uword i) const + { + return (*mem[i]); + } + + + +//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +oT& +field::operator() (const uword i) + { + arma_debug_check( (i >= n_elem), "field::operator(): index out of bounds"); + return (*mem[i]); + } + + + +//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +const oT& +field::operator() (const uword i) const + { + arma_debug_check( (i >= n_elem), "field::operator(): index out of bounds"); + return (*mem[i]); + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +oT& +field::operator() (const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "field::operator(): index out of bounds"); + return (*mem[in_row + in_col*n_rows]); + } + + + +//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined +template +arma_inline +const oT& +field::operator() (const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "field::operator(): index out of bounds"); + return (*mem[in_row + in_col*n_rows]); + } + + + +//! element accessor; no bounds check +template +arma_inline +oT& +field::at(const uword in_row, const uword in_col) + { + return (*mem[in_row + in_col*n_rows]); + } + + + +//! element accessor; no bounds check +template +arma_inline +const oT& +field::at(const uword in_row, const uword in_col) const + { + return (*mem[in_row + in_col*n_rows]); + } + + + +template +inline +field_injector< field > +field::operator<<(const oT& val) + { + return field_injector< field >(*this, val); + } + + + +template +inline +field_injector< field > +field::operator<<(const injector_end_of_row& x) + { + return field_injector< field >(*this, x); + } + + + +//! creation of subview_field (row of a field) +template +inline +subview_field +field::row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "field::row(): row out of bounds" ); + + return subview_field(*this, row_num, 0, 1, n_cols); + } + + + +//! creation of subview_field (row of a field) +template +inline +const subview_field +field::row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (row_num >= n_rows), "field::row(): row out of bounds" ); + + return subview_field(*this, row_num, 0, 1, n_cols); + } + + + +//! creation of subview_field (column of a field) +template +inline +subview_field +field::col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "field::col(): out of bounds"); + + return subview_field(*this, 0, col_num, n_rows, 1); + } + + + +//! creation of subview_field (column of a field) +template +inline +const subview_field +field::col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( (col_num >= n_cols), "field::col(): out of bounds"); + + return subview_field(*this, 0, col_num, n_rows, 1); + } + + + +//! creation of subview_field (subfield comprised of specified rows) +template +inline +subview_field +field::rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + ( (in_row1 > in_row2) || (in_row2 >= n_rows) ), + "field::rows(): indicies out of bounds or incorrectly used" + ); + + const uword sub_n_rows = in_row2 - in_row1 + 1; + + return subview_field(*this, in_row1, 0, sub_n_rows, n_cols); + } + + + +//! creation of subview_field (subfield comprised of specified rows) +template +inline +const subview_field +field::rows(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + ( (in_row1 > in_row2) || (in_row2 >= n_rows) ), + "field::rows(): indicies out of bounds or incorrectly used" + ); + + const uword sub_n_rows = in_row2 - in_row1 + 1; + + return subview_field(*this, in_row1, 0, sub_n_rows, n_cols); + } + + + +//! creation of subview_field (subfield comprised of specified columns) +template +inline +subview_field +field::cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + ( (in_col1 > in_col2) || (in_col2 >= n_cols) ), + "field::cols(): indicies out of bounds or incorrectly used" + ); + + const uword sub_n_cols = in_col2 - in_col1 + 1; + + return subview_field(*this, 0, in_col1, n_rows, sub_n_cols); + } + + + +//! creation of subview_field (subfield comprised of specified columns) +template +inline +const subview_field +field::cols(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + ( (in_col1 > in_col2) || (in_col2 >= n_cols) ), + "field::cols(): indicies out of bounds or incorrectly used" + ); + + const uword sub_n_cols = in_col2 - in_col1 + 1; + + return subview_field(*this, 0, in_col1, n_rows, sub_n_cols); + } + + + +//! creation of subview_field (subfield with arbitrary dimensions) +template +inline +subview_field +field::subfield(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "field::subfield(): indices out of bounds or incorrectly used" + ); + + const uword sub_n_rows = in_row2 - in_row1 + 1; + const uword sub_n_cols = in_col2 - in_col1 + 1; + + return subview_field(*this, in_row1, in_col1, sub_n_rows, sub_n_cols); + } + + + +//! creation of subview_field (subfield with arbitrary dimensions) +template +inline +const subview_field +field::subfield(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "field::subfield(): indices out of bounds or incorrectly used" + ); + + const uword sub_n_rows = in_row2 - in_row1 + 1; + const uword sub_n_cols = in_col2 - in_col1 + 1; + + return subview_field(*this, in_row1, in_col1, sub_n_rows, sub_n_cols); + } + + + +//! creation of subview_field (subfield with arbitrary dimensions) +template +inline +subview_field +field::subfield(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword sub_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword sub_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "field::subfield(): indices out of bounds or incorrectly used" + ); + + return subview_field(*this, in_row1, in_col1, sub_n_rows, sub_n_cols); + } + + + +//! creation of subview_field (subfield with arbitrary dimensions) +template +inline +const subview_field +field::subfield(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword sub_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword sub_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "field::subfield(): indices out of bounds or incorrectly used" + ); + + return subview_field(*this, in_row1, in_col1, sub_n_rows, sub_n_cols); + } + + + +template +inline +subview_field +field::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return (*this).subfield(row_span, col_span); + } + + + +template +inline +const subview_field +field::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return (*this).subfield(row_span, col_span); + } + + + +//! print contents of the field (to the cout stream), +//! optionally preceding with a user specified line of text. +//! the field class preserves the stream's flags +//! but the associated operator<< function for type oT +//! may still modify the stream's parameters. +//! NOTE: this function assumes that type oT can be printed, +//! i.e. the function "std::ostream& operator<< (std::ostream&, const oT&)" +//! has been defined. + +template +inline +void +field::print(const std::string extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = ARMA_DEFAULT_OSTREAM.width(); + + ARMA_DEFAULT_OSTREAM << extra_text << '\n'; + + ARMA_DEFAULT_OSTREAM.width(orig_width); + } + + arma_ostream::print(ARMA_DEFAULT_OSTREAM, *this); + } + + + +//! print contents of the field to a user specified stream, +//! optionally preceding with a user specified line of text. +//! the field class preserves the stream's flags +//! but the associated operator<< function for type oT +//! may still modify the stream's parameters. +//! NOTE: this function assumes that type oT can be printed, +//! i.e. the function "std::ostream& operator<< (std::ostream&, const oT&)" +//! has been defined. + +template +inline +void +field::print(std::ostream& user_stream, const std::string extra_text) const + { + arma_extra_debug_sigprint(); + + if(extra_text.length() != 0) + { + const std::streamsize orig_width = user_stream.width(); + + user_stream << extra_text << '\n'; + + user_stream.width(orig_width); + } + + arma_ostream::print(user_stream, *this); + } + + + +//! fill the field with an object +template +inline +void +field::fill(const oT& x) + { + arma_extra_debug_sigprint(); + + field& t = *this; + + for(uword i=0; i +inline +void +field::reset() + { + arma_extra_debug_sigprint(); + + init(0,0); + } + + + +//! reset each object +template +inline +void +field::reset_objects() + { + arma_extra_debug_sigprint(); + + field_aux::reset_objects(*this); + } + + + +//! returns true if the field has no objects +template +arma_inline +bool +field::is_empty() const + { + return (n_elem == 0); + } + + + +//! returns true if the given index is currently in range +template +arma_inline +arma_warn_unused +bool +field::in_range(const uword i) const + { + return (i < n_elem); + } + + + +//! returns true if the given start and end indices are currently in range +template +arma_inline +arma_warn_unused +bool +field::in_range(const span& x) const + { + arma_extra_debug_sigprint(); + + if(x.whole == true) + { + return true; + } + else + { + const uword a = x.a; + const uword b = x.b; + + return ( (a <= b) && (b < n_elem) ); + } + } + + + +//! returns true if the given location is currently in range +template +arma_inline +arma_warn_unused +bool +field::in_range(const uword in_row, const uword in_col) const + { + return ( (in_row < n_rows) && (in_col < n_cols) ); + } + + + +template +arma_inline +arma_warn_unused +bool +field::in_range(const span& row_span, const uword in_col) const + { + arma_extra_debug_sigprint(); + + if(row_span.whole == true) + { + return (in_col < n_cols); + } + else + { + const uword in_row1 = row_span.a; + const uword in_row2 = row_span.b; + + return ( (in_row1 <= in_row2) && (in_row2 < n_rows) && (in_col < n_cols) ); + } + } + + + +template +arma_inline +arma_warn_unused +bool +field::in_range(const uword in_row, const span& col_span) const + { + arma_extra_debug_sigprint(); + + if(col_span.whole == true) + { + return (in_row < n_rows); + } + else + { + const uword in_col1 = col_span.a; + const uword in_col2 = col_span.b; + + return ( (in_row < n_rows) && (in_col1 <= in_col2) && (in_col2 < n_cols) ); + } + } + + + +template +arma_inline +arma_warn_unused +bool +field::in_range(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const uword in_row1 = row_span.a; + const uword in_row2 = row_span.b; + + const uword in_col1 = col_span.a; + const uword in_col2 = col_span.b; + + const bool rows_ok = row_span.whole ? true : ( (in_row1 <= in_row2) && (in_row2 < n_rows) ); + const bool cols_ok = col_span.whole ? true : ( (in_col1 <= in_col2) && (in_col2 < n_cols) ); + + return ( (rows_ok == true) && (cols_ok == true) ); + } + + + +template +inline +bool +field::save(const std::string name, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + std::string err_msg; + const bool save_okay = field_aux::save(*this, name, type, err_msg); + + if( (print_status == true) && (save_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "field::save(): ", err_msg, name); + } + else + { + arma_warn(true, "field::save(): couldn't write to ", name); + } + } + + return save_okay; + } + + + +template +inline +bool +field::save(std::ostream& os, const file_type type, const bool print_status) const + { + arma_extra_debug_sigprint(); + + std::string err_msg; + const bool save_okay = field_aux::save(*this, os, type, err_msg); + + if( (print_status == true) && (save_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "field::save(): ", err_msg, "[ostream]"); + } + else + { + arma_warn(true, "field::save(): couldn't write to [ostream]"); + } + } + + return save_okay; + } + + + +template +inline +bool +field::load(const std::string name, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + std::string err_msg; + const bool load_okay = field_aux::load(*this, name, type, err_msg); + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "field::load(): ", err_msg, name); + } + else + { + arma_warn(true, "field::load(): couldn't read from ", name); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +template +inline +bool +field::load(std::istream& is, const file_type type, const bool print_status) + { + arma_extra_debug_sigprint(); + + std::string err_msg; + const bool load_okay = field_aux::load(*this, is, type, err_msg); + + if( (print_status == true) && (load_okay == false) ) + { + if(err_msg.length() > 0) + { + arma_warn(true, "field::load(): ", err_msg, "[istream]"); + } + else + { + arma_warn(true, "field::load(): couldn't read from [istream]"); + } + } + + if(load_okay == false) + { + (*this).reset(); + } + + return load_okay; + } + + + +template +inline +bool +field::quiet_save(const std::string name, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(name, type, false); + } + + + +template +inline +bool +field::quiet_save(std::ostream& os, const file_type type) const + { + arma_extra_debug_sigprint(); + + return (*this).save(os, type, false); + } + + + +template +inline +bool +field::quiet_load(const std::string name, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(name, type, false); + } + + + +template +inline +bool +field::quiet_load(std::istream& is, const file_type type) + { + arma_extra_debug_sigprint(); + + return (*this).load(is, type, false); + } + + + +//! construct a field from a given field +template +inline +void +field::init(const field& x) + { + arma_extra_debug_sigprint(); + + if(this != &x) + { + init(x.n_rows, x.n_cols); + + field& t = *this; + + for(uword col=0; col +inline +void +field::init(const uword n_rows_in, const uword n_cols_in) + { + arma_extra_debug_sigprint( arma_boost::format("n_rows_in = %d, n_cols_in = %d") % n_rows_in % n_cols_in ); + + const uword n_elem_new = n_rows_in * n_cols_in; + + if(n_elem == n_elem_new) + { + // delete_objects(); + // create_objects(); + access::rw(n_rows) = n_rows_in; + access::rw(n_cols) = n_cols_in; + } + else + { + delete_objects(); + + if(n_elem > sizeof(mem_local)/sizeof(oT*) ) + { + delete [] mem; + } + + if(n_elem_new <= sizeof(mem_local)/sizeof(oT*) ) + { + mem = mem_local; + } + else + { + mem = new(std::nothrow) oT* [n_elem_new]; + arma_check_bad_alloc( (mem == 0), "field::init(): out of memory" ); + } + + access::rw(n_elem) = n_elem_new; + + if(n_elem_new == 0) + { + access::rw(n_rows) = 0; + access::rw(n_cols) = 0; + } + else + { + access::rw(n_rows) = n_rows_in; + access::rw(n_cols) = n_cols_in; + } + + create_objects(); + + } + + } + + + +template +inline +void +field::delete_objects() + { + arma_extra_debug_sigprint( arma_boost::format("n_elem = %d") % n_elem ); + + for(uword i=0; i +inline +void +field::create_objects() + { + arma_extra_debug_sigprint( arma_boost::format("n_elem = %d") % n_elem ); + + for(uword i=0; i +inline +field::iterator::iterator(field& in_M, const bool at_end) + : M(in_M) + , i( (at_end == false) ? 0 : in_M.n_elem ) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +oT& +field::iterator::operator*() + { + return M[i]; + } + + + +template +inline +typename field::iterator& +field::iterator::operator++() + { + ++i; + + return *this; + } + + + +template +inline +void +field::iterator::operator++(int) + { + operator++(); + } + + + +template +inline +typename field::iterator& +field::iterator::operator--() + { + if(i > 0) + { + --i; + } + + return *this; + } + + + +template +inline +void +field::iterator::operator--(int) + { + operator--(); + } + + + +template +inline +bool +field::iterator::operator!=(const typename field::iterator& X) const + { + return (i != X.i); + } + + + +template +inline +bool +field::iterator::operator==(const typename field::iterator& X) const + { + return (i == X.i); + } + + + +template +inline +field::const_iterator::const_iterator(const field& in_M, const bool at_end) + : M(in_M) + , i( (at_end == false) ? 0 : in_M.n_elem ) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +field::const_iterator::const_iterator(const typename field::iterator& X) + : M(X.M) + , i(X.i) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +const oT& +field::const_iterator::operator*() const + { + return M[i]; + } + + + +template +inline +typename field::const_iterator& +field::const_iterator::operator++() + { + ++i; + + return *this; + } + + + +template +inline +void +field::const_iterator::operator++(int) + { + operator++(); + } + + + +template +inline +typename field::const_iterator& +field::const_iterator::operator--() + { + if(i > 0) + { + --i; + } + + return *this; + } + + + +template +inline +void +field::const_iterator::operator--(int) + { + operator--(); + } + + + +template +inline +bool +field::const_iterator::operator!=(const typename field::const_iterator& X) const + { + return (i != X.i); + } + + + +template +inline +bool +field::const_iterator::operator==(const typename field::const_iterator& X) const + { + return (i == X.i); + } + + + +template +inline +typename field::iterator +field::begin() + { + arma_extra_debug_sigprint(); + + return field::iterator(*this); + } + + + +template +inline +typename field::const_iterator +field::begin() const + { + arma_extra_debug_sigprint(); + + return field::const_iterator(*this); + } + + + +template +inline +typename field::iterator +field::end() + { + arma_extra_debug_sigprint(); + + return field::iterator(*this, true); + } + + + +template +inline +typename field::const_iterator +field::end() const + { + arma_extra_debug_sigprint(); + + return field::const_iterator(*this, true); + } + + + +// +// +// + + + +template +inline +void +field_aux::reset_objects(field& x) + { + arma_extra_debug_sigprint(); + + x.delete_objects(); + x.create_objects(); + } + + + +template +inline +void +field_aux::reset_objects(field< Mat >& x) + { + arma_extra_debug_sigprint(); + + for(uword i=0; i +inline +void +field_aux::reset_objects(field< Col >& x) + { + arma_extra_debug_sigprint(); + + for(uword i=0; i +inline +void +field_aux::reset_objects(field< Row >& x) + { + arma_extra_debug_sigprint(); + + for(uword i=0; i +inline +void +field_aux::reset_objects(field< Cube >& x) + { + arma_extra_debug_sigprint(); + + for(uword i=0; i& x) + { + arma_extra_debug_sigprint(); + + for(uword i=0; i +inline +bool +field_aux::save(const field& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + err_msg = " [sorry, saving/loading this type of field is currently not supported] filename = "; + + return false; + } + + + +template +inline +bool +field_aux::save(const field& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + err_msg = " [sorry, saving/loading this type of field is currently not supported] filename = "; + + return false; + } + + + +template +inline +bool +field_aux::load(field& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + err_msg = " [sorry, saving/loading this type of field is currently not supported] filename = "; + + return false; + } + + + +template +inline +bool +field_aux::load(field& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + err_msg = " [sorry, saving/loading this type of field is currently not supported] filename = "; + + return false; + } + + + +template +inline +bool +field_aux::save(const field< Mat >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, name); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, name); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Mat >& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, os); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, os); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Mat >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, name, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Mat >& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, is, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, is, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, is, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Col >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, name); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, name); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Col >& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, os); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, os); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Col >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, name, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Col >& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, is, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, is, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, is, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Row >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Row >& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, os, err_msg); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, os, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Row >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, name, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Row >& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, is, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, is, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, is, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Cube >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::save(const field< Cube >& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case arma_binary: + return diskio::save_arma_binary(x, os, err_msg); + break; + + case ppm_binary: + return diskio::save_ppm_binary(x, os, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Cube >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, name, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, name, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, name, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +template +inline +bool +field_aux::load(field< Cube >& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + switch(type) + { + case auto_detect: + return diskio::load_auto_detect(x, is, err_msg); + break; + + case arma_binary: + return diskio::load_arma_binary(x, is, err_msg); + break; + + case ppm_binary: + return diskio::load_ppm_binary(x, is, err_msg); + break; + + default: + err_msg = " [unsupported type] filename = "; + return false; + } + } + + + +inline +bool +field_aux::save(const field< std::string >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_ignore(type); + + err_msg.clear(); + + return diskio::save_std_string(x, name); + } + + + +inline +bool +field_aux::save(const field< std::string >& x, std::ostream& os, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_ignore(type); + + err_msg.clear(); + + return diskio::save_std_string(x, os); + } + + + +inline +bool +field_aux::load(field< std::string >& x, const std::string& name, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_ignore(type); + + return diskio::load_std_string(x, name, err_msg); + } + + + +inline +bool +field_aux::load(field< std::string >& x, std::istream& is, const file_type type, std::string& err_msg) + { + arma_extra_debug_sigprint(); + + arma_ignore(type); + + return diskio::load_std_string(x, is, err_msg); + } + + + +#ifdef ARMA_EXTRA_FIELD_MEAT + #include ARMA_INCFILE_WRAP(ARMA_EXTRA_FIELD_MEAT) +#endif + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_accu.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_accu.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,279 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_accu +//! @{ + + + +//! accumulate the elements of a matrix +template +arma_hot +inline +typename T1::elem_type +accu(const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type; + + const Proxy A(X.get_ref()); + + if(Proxy::prefer_at_accessor == false) + { + ea_type P = A.get_ea(); + const uword n_elem = A.get_n_elem(); + + eT val1 = eT(0); + eT val2 = eT(0); + + uword i,j; + + for(i=0, j=1; j +arma_inline +arma_warn_unused +uword +accu(const mtOp& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const Proxy A(X.m); + + const uword n_elem = A.get_n_elem(); + const eT val = X.aux; + + uword n_nonzero = 0; + for(uword i=0; i +arma_hot +arma_warn_unused +inline +typename T1::elem_type +accu(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename ProxyCube::ea_type ea_type; + + const ProxyCube A(X.get_ref()); + + if(ProxyCube::prefer_at_accessor == false) + { + + ea_type P = A.get_ea(); + const uword n_elem = A.get_n_elem(); + + eT val1 = eT(0); + eT val2 = eT(0); + + uword i,j; + + for(i=0, j=1; j +arma_pure +arma_warn_unused +inline +eT +accu(const diagview& X) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.n_elem; + + eT val = eT(0); + + for(uword i=0; i +arma_pure +arma_warn_unused +inline +eT +accu(const subview& S) + { + arma_extra_debug_sigprint(); + + const uword S_n_rows = S.n_rows; + const uword S_n_cols = S.n_cols; + const uword S_n_elem = S.n_elem; + + eT val = eT(0); + + if(S_n_elem > 0) + { + for(uword col=0; col +arma_pure +arma_warn_unused +inline +eT +accu(const subview_row& S) + { + arma_extra_debug_sigprint(); + + const Mat& X = S.m; + + const uword n_elem = S.n_elem; + const uword row = S.aux_row1; + const uword start_col = S.aux_col1; + const uword end_col_p1 = start_col + S.n_cols; + + eT val = eT(0); + + if(n_elem > 0) + { + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_p1; i+=2, j+=2) + { + val += X.at(row,i); + val += X.at(row,j); + } + + if(i < end_col_p1) + { + val += X.at(row,i); + } + } + + return val; + } + + + +//! accumulate the elements of a subview_col +template +arma_pure +arma_warn_unused +inline +eT +accu(const subview_col& S) + { + arma_extra_debug_sigprint(); + + return (S.n_elem > 0) ? arrayops::accumulate( S.colptr(0), S.n_rows ) : eT(0); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_as_scalar.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_as_scalar.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,357 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_as_scalar +//! @{ + + + +template +struct as_scalar_redirect + { + template + inline static typename T1::elem_type apply(const T1& X); + }; + + + +template<> +struct as_scalar_redirect<2> + { + template + inline static typename T1::elem_type apply(const Glue& X); + }; + + +template<> +struct as_scalar_redirect<3> + { + template + inline static typename T1::elem_type apply(const Glue< Glue, T3, glue_times>& X); + }; + + + +template +template +inline +typename T1::elem_type +as_scalar_redirect::apply(const T1& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X); + const Mat& A = tmp.M; + + arma_debug_check( (A.n_elem != 1), "as_scalar(): expression doesn't evaluate to exactly one element" ); + + return A.mem[0]; + } + + + +template +inline +typename T1::elem_type +as_scalar_redirect<2>::apply(const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + // T1 must result in a matrix with one row + // T2 must result in a matrix with one column + + const partial_unwrap tmp1(X.A); + const partial_unwrap tmp2(X.B); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + const uword A_n_rows = (tmp1.do_trans == false) ? A.n_rows : A.n_cols; + const uword A_n_cols = (tmp1.do_trans == false) ? A.n_cols : A.n_rows; + + const uword B_n_rows = (tmp2.do_trans == false) ? B.n_rows : B.n_cols; + const uword B_n_cols = (tmp2.do_trans == false) ? B.n_cols : B.n_rows; + + const eT val = tmp1.get_val() * tmp2.get_val(); + + arma_debug_check( (A_n_rows != 1) || (B_n_cols != 1) || (A_n_cols != B_n_rows), "as_scalar(): incompatible dimensions" ); + + return val * op_dot::direct_dot(A.n_elem, A.mem, B.mem); + } + + + +template +inline +typename T1::elem_type +as_scalar_redirect<3>::apply(const Glue< Glue, T3, glue_times >& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + // T1 * T2 must result in a matrix with one row + // T3 must result in a matrix with one column + + typedef typename strip_inv ::stored_type T2_stripped_1; + typedef typename strip_diagmat::stored_type T2_stripped_2; + + const strip_inv strip1(X.A.B); + const strip_diagmat strip2(strip1.M); + + const bool tmp2_do_inv = strip1.do_inv; + const bool tmp2_do_diagmat = strip2.do_diagmat; + + if(tmp2_do_diagmat == false) + { + const Mat tmp(X); + + arma_debug_check( (tmp.n_elem != 1), "as_scalar(): expression doesn't evaluate to exactly one element" ); + + return tmp[0]; + } + else + { + const partial_unwrap tmp1(X.A.A); + const partial_unwrap tmp2(strip2.M); + const partial_unwrap tmp3(X.B); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + const Mat& C = tmp3.M; + + const uword A_n_rows = (tmp1.do_trans == false) ? A.n_rows : A.n_cols; + const uword A_n_cols = (tmp1.do_trans == false) ? A.n_cols : A.n_rows; + + const bool B_is_vec = B.is_vec(); + + const uword B_n_rows = (B_is_vec == true) ? B.n_elem : ( (tmp2.do_trans == false) ? B.n_rows : B.n_cols ); + const uword B_n_cols = (B_is_vec == true) ? B.n_elem : ( (tmp2.do_trans == false) ? B.n_cols : B.n_rows ); + + const uword C_n_rows = (tmp3.do_trans == false) ? C.n_rows : C.n_cols; + const uword C_n_cols = (tmp3.do_trans == false) ? C.n_cols : C.n_rows; + + const eT val = tmp1.get_val() * tmp2.get_val() * tmp3.get_val(); + + arma_debug_check + ( + (A_n_rows != 1) || + (C_n_cols != 1) || + (A_n_cols != B_n_rows) || + (B_n_cols != C_n_rows) + , + "as_scalar(): incompatible dimensions" + ); + + + if(B_is_vec == true) + { + if(tmp2_do_inv == true) + { + return val * op_dotext::direct_rowvec_invdiagvec_colvec(A.mem, B, C.mem); + } + else + { + return val * op_dot::direct_dot(A.n_elem, A.mem, B.mem, C.mem); + } + } + else + { + if(tmp2_do_inv == true) + { + return val * op_dotext::direct_rowvec_invdiagmat_colvec(A.mem, B, C.mem); + } + else + { + return val * op_dotext::direct_rowvec_diagmat_colvec(A.mem, B, C.mem); + } + } + } + } + + + +template +inline +typename T1::elem_type +as_scalar_diag(const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + arma_debug_check( (A.n_elem != 1), "as_scalar(): expression doesn't evaluate to exactly one element" ); + + return A.mem[0]; + } + + + +template +inline +typename T1::elem_type +as_scalar_diag(const Glue< Glue, T3, glue_times >& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + // T1 * T2 must result in a matrix with one row + // T3 must result in a matrix with one column + + typedef typename strip_diagmat::stored_type T2_stripped; + + const strip_diagmat strip(X.A.B); + + const partial_unwrap tmp1(X.A.A); + const partial_unwrap tmp2(strip.M); + const partial_unwrap tmp3(X.B); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + const Mat& C = tmp3.M; + + + const uword A_n_rows = (tmp1.do_trans == false) ? A.n_rows : A.n_cols; + const uword A_n_cols = (tmp1.do_trans == false) ? A.n_cols : A.n_rows; + + const bool B_is_vec = B.is_vec(); + + const uword B_n_rows = (B_is_vec == true) ? B.n_elem : ( (tmp2.do_trans == false) ? B.n_rows : B.n_cols ); + const uword B_n_cols = (B_is_vec == true) ? B.n_elem : ( (tmp2.do_trans == false) ? B.n_cols : B.n_rows ); + + const uword C_n_rows = (tmp3.do_trans == false) ? C.n_rows : C.n_cols; + const uword C_n_cols = (tmp3.do_trans == false) ? C.n_cols : C.n_rows; + + const eT val = tmp1.get_val() * tmp2.get_val() * tmp3.get_val(); + + arma_debug_check + ( + (A_n_rows != 1) || + (C_n_cols != 1) || + (A_n_cols != B_n_rows) || + (B_n_cols != C_n_rows) + , + "as_scalar(): incompatible dimensions" + ); + + + if(B_is_vec == true) + { + return val * op_dot::direct_dot(A.n_elem, A.mem, B.mem, C.mem); + } + else + { + return val * op_dotext::direct_rowvec_diagmat_colvec(A.mem, B, C.mem); + } + } + + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +as_scalar(const Glue& X, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + if(is_glue_times_diag::value == false) + { + const sword N_mat = 1 + depth_lhs< glue_times, Glue >::num; + + arma_extra_debug_print(arma_boost::format("N_mat = %d") % N_mat); + + return as_scalar_redirect::apply(X); + } + else + { + return as_scalar_diag(X); + } + } + + + +template +inline +arma_warn_unused +typename T1::elem_type +as_scalar(const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + arma_debug_check( (A.n_elem != 1), "as_scalar(): expression doesn't evaluate to exactly one element" ); + + return A.mem[0]; + } + + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +as_scalar(const eOp& X) + { + arma_extra_debug_sigprint(); + + return -(as_scalar(X.P.Q)); + } + + + +template +inline +arma_warn_unused +typename T1::elem_type +as_scalar(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_cube tmp(X.get_ref()); + const Cube& A = tmp.M; + + arma_debug_check( (A.n_elem != 1), "as_scalar(): expression doesn't evaluate to exactly one element" ); + + return A.mem[0]; + } + + + +template +arma_inline +arma_warn_unused +const typename arma_scalar_only::result & +as_scalar(const T& x) + { + return x; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_chol.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_chol.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,63 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_chol +//! @{ + + + +template +inline +const Op +chol + ( + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Op(X.get_ref()); + } + + + +template +inline +bool +chol + ( + Mat& out, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + try + { + out = chol(X); + } + catch(std::runtime_error&) + { + return false; + } + + return true; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_conv.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_conv.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,33 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_conv +//! @{ + + + +//! Convolution, which is also equivalent to polynomial multiplication and FIR digital filtering. + +template +inline +const Glue +conv(const Base& A, const Base& B) + { + arma_extra_debug_sigprint(); + + return Glue(A.get_ref(), B.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_conv_to.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_conv_to.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1102 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_conv_to +//! @{ + + + +//! conversion from Armadillo Base and BaseCube objects to scalars +//! (kept only for compatibility with old code; use as_scalar() instead for Base objects like Mat) +template +class conv_to + { + public: + + template + inline static out_eT from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static out_eT from(const Base& in, const typename arma_cx_only::result* junk = 0); + + template + inline static out_eT from(const BaseCube& in, const typename arma_not_cx::result* junk = 0); + + template + inline static out_eT from(const BaseCube& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +out_eT +conv_to::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + arma_type_check(( is_supported_elem_type::value == false )); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.n_elem != 1), "conv_to(): given object doesn't have exactly one element" ); + + return out_eT(X.mem[0]); + } + + + +template +template +inline +out_eT +conv_to::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + arma_type_check(( is_supported_elem_type::value == false )); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.n_elem != 1), "conv_to(): given object doesn't have exactly one element" ); + + out_eT out; + + arrayops::convert_cx_scalar(out, X.mem[0]); + + return out; + } + + + +template +template +inline +out_eT +conv_to::from(const BaseCube& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + arma_type_check(( is_supported_elem_type::value == false )); + + const unwrap_cube tmp(in.get_ref()); + const Cube& X = tmp.M; + + arma_debug_check( (X.n_elem != 1), "conv_to(): given object doesn't have exactly one element" ); + + return out_eT(X.mem[0]); + } + + + +template +template +inline +out_eT +conv_to::from(const BaseCube& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + arma_type_check(( is_supported_elem_type::value == false )); + + const unwrap_cube tmp(in.get_ref()); + const Cube& X = tmp.M; + + arma_debug_check( (X.n_elem != 1), "conv_to(): given object doesn't have exactly one element" ); + + out_eT out; + + arrayops::convert_cx_scalar(out, X.mem[0]); + + return out; + } + + + +//! conversion to Armadillo matrices from Armadillo Base objects, +//! as well as from std::vector, itpp::Mat and itpp::Vec +template +class conv_to< Mat > + { + public: + + template + inline static Mat from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Mat from(const Base& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Mat from(const std::vector& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Mat from(const std::vector& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Mat from(const itpp::Mat& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Mat from(const itpp::Mat& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Mat from(const itpp::Vec& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Mat from(const itpp::Vec& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +Mat +conv_to< Mat >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + Mat out(X.n_rows, X.n_cols); + + arrayops::convert( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + Mat out(X.n_rows, X.n_cols); + + arrayops::convert_cx( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const std::vector& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.size(), 1); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Mat::iterator out_begin = out.begin(); + typename Mat::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Mat::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + (*out_it) = out_eT(*in_it); + } + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const std::vector& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.size(), 1); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Mat::iterator out_begin = out.begin(); + typename Mat::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Mat::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + out_eT& out_elem = (*out_it); + const in_eT& in_elem = (*in_it); + + arrayops::convert_cx_scalar(out_elem, in_elem); + } + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const itpp::Mat& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.rows(), in.cols()); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const itpp::Mat& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.rows(), in.cols()); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const itpp::Vec& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.length(), 1); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Mat +conv_to< Mat >::from(const itpp::Vec& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Mat out(in.length(), 1); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +//! conversion to Armadillo row vectors from Armadillo Base objects, +//! as well as from std::vector, itpp::Mat and itpp::Vec +template +class conv_to< Row > + { + public: + + template + inline static Row from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Row from(const Base& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Row from(const std::vector& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Row from(const std::vector& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Row from(const itpp::Mat& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Row from(const itpp::Mat& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Row from(const itpp::Vec& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Row from(const itpp::Vec& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +Row +conv_to< Row >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + Row out(X.n_elem); + + arrayops::convert( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + Row out(X.n_rows, X.n_cols); + + arrayops::convert_cx( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const std::vector& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Row out( in.size() ); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Row::iterator out_begin = out.begin(); + typename Row::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Row::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + (*out_it) = out_eT(*in_it); + } + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const std::vector& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Row out( in.size() ); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Row::iterator out_begin = out.begin(); + typename Row::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Row::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + out_eT& out_elem = (*out_it); + const in_eT& in_elem = (*in_it); + + arrayops::convert_cx_scalar(out_elem, in_elem); + } + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const itpp::Mat& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const bool is_vec = ( (in.rows() == 1) || (in.cols() == 1) ); + + arma_debug_check( (is_vec == false), "conv_to(): given object can't be interpreted as a vector" ); + + Row out(in.rows() * in.cols()); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const itpp::Mat& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + //const bool is_vec = ( (in.rows() == 1) || (in.cols() == 1) ); + + Row out(in.rows() * in.cols()); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const itpp::Vec& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Row out(in.length()); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Row +conv_to< Row >::from(const itpp::Vec& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Row out(in.length()); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +//! conversion to Armadillo column vectors from Armadillo Base objects, +//! as well as from std::vector, itpp::Mat and itpp::Vec +template +class conv_to< Col > + { + public: + + template + inline static Col from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Col from(const Base& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Col from(const std::vector& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Col from(const std::vector& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Col from(const itpp::Mat& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Col from(const itpp::Mat& in, const typename arma_cx_only::result* junk = 0); + + + + template + inline static Col from(const itpp::Vec& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Col from(const itpp::Vec& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +Col +conv_to< Col >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + Col out(X.n_elem); + + arrayops::convert( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + Col out(X.n_rows, X.n_cols); + + arrayops::convert_cx( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const std::vector& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Col out( in.size() ); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Col::iterator out_begin = out.begin(); + typename Col::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Col::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + (*out_it) = out_eT(*in_it); + } + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const std::vector& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Col out( in.size() ); + + typename std::vector::const_iterator in_begin = in.begin(); + typename std::vector::const_iterator in_end = in.end(); + + typename Col::iterator out_begin = out.begin(); + typename Col::iterator out_end = out.end(); + + typename std::vector::const_iterator in_it; + typename Col::iterator out_it; + + for(in_it = in_begin, out_it = out_begin; (in_it != in_end) && (out_it != out_end); ++in_it, ++out_it) + { + out_eT& out_elem = (*out_it); + const in_eT& in_elem = (*in_it); + + arrayops::convert_cx_scalar(out_elem, in_elem); + } + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const itpp::Mat& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const bool is_vec = ( (in.rows() == 1) || (in.cols() == 1) ); + + arma_debug_check( (is_vec == false), "conv_to(): given object can't be interpreted as a vector" ); + + Col out(in.rows() * in.cols()); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const itpp::Mat& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + //const bool is_vec = ( (in.rows() == 1) || (in.cols() == 1) ); + + Col out(in.rows() * in.cols()); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const itpp::Vec& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Col out( in.length() ); + + arrayops::convert( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +template +template +inline +Col +conv_to< Col >::from(const itpp::Vec& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + Col out( in.length() ); + + arrayops::convert_cx( out.memptr(), in._data(), out.n_elem ); + + return out; + } + + + +//! conversion to Armadillo cubes from Armadillo BaseCube objects +template +class conv_to< Cube > + { + public: + + template + inline static Cube from(const BaseCube& in, const typename arma_not_cx::result* junk = 0); + + template + inline static Cube from(const BaseCube& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +Cube +conv_to< Cube >::from(const BaseCube& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap_cube tmp( in.get_ref() ); + const Cube& X = tmp.M; + + Cube out(X.n_rows, X.n_cols, X.n_slices); + + arrayops::convert( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +template +template +inline +Cube +conv_to< Cube >::from(const BaseCube& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap_cube tmp( in.get_ref() ); + const Cube& X = tmp.M; + + Cube out(X.n_rows, X.n_cols, X.n_slices); + + arrayops::convert_cx( out.memptr(), X.memptr(), out.n_elem ); + + return out; + } + + + +//! conversion to std::vector from Armadillo Base objects +template +class conv_to< std::vector > + { + public: + + template + inline static std::vector from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static std::vector from(const Base& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +std::vector +conv_to< std::vector >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + std::vector out(X.n_elem); + + typename Mat::const_iterator X_begin = X.begin(); + typename Mat::const_iterator X_end = X.end(); + + typename std::vector::iterator out_begin = out.begin(); + typename std::vector::iterator out_end = out.end(); + + typename Mat::const_iterator X_it; + typename std::vector::iterator out_it; + + for(X_it = X_begin, out_it = out_begin; (X_it != X_end) && (out_it != out_end); ++X_it, ++out_it) + { + (*out_it) = out_eT(*X_it); + } + + return out; + } + + + +template +template +inline +std::vector +conv_to< std::vector >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp(in.get_ref()); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + std::vector out(X.n_elem); + + typename Mat::const_iterator X_begin = X.begin(); + typename Mat::const_iterator X_end = X.end(); + + typename std::vector::iterator out_begin = out.begin(); + typename std::vector::iterator out_end = out.end(); + + typename Mat::const_iterator X_it; + typename std::vector::iterator out_it; + + for(X_it = X_begin, out_it = out_begin; (X_it != X_end) && (out_it != out_end); ++X_it, ++out_it) + { + out_eT& out_elem = (*out_it); + const in_eT& X_elem = (*X_it); + + arrayops::convert_cx_scalar(out_elem, X_elem); + } + + return out; + } + + + +//! conversion to itpp::Mat from Armadillo Base objects +template +class conv_to< itpp::Mat > + { + public: + + template + inline static itpp::Mat from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static itpp::Mat from(const Base& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +itpp::Mat +conv_to< itpp::Mat >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp( in.get_ref() ); + const Mat& X = tmp.M; + + itpp::Mat out(X.n_rows, X.n_cols); + + arrayops::convert( out._data(), X.memptr(), X.n_elem ); + + return out; + } + + + +template +template +inline +itpp::Mat +conv_to< itpp::Mat >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp( in.get_ref() ); + const Mat& X = tmp.M; + + itpp::Mat out(X.n_rows, X.n_cols); + + arrayops::convert_cx( out._data(), X.memptr(), X.n_elem ); + + return out; + } + + + + +//! conversion to itpp::Vec from Armadillo Base objects +template +class conv_to< itpp::Vec > + { + public: + + template + inline static itpp::Vec from(const Base& in, const typename arma_not_cx::result* junk = 0); + + template + inline static itpp::Vec from(const Base& in, const typename arma_cx_only::result* junk = 0); + }; + + + +template +template +inline +itpp::Vec +conv_to< itpp::Vec >::from(const Base& in, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp( in.get_ref() ); + const Mat& X = tmp.M; + + arma_debug_check( (X.is_vec() == false), "conv_to(): given object can't be interpreted as a vector" ); + + itpp::Vec out(X.n_elem); + + arrayops::convert( out._data(), X.memptr(), X.n_elem ); + + return out; + } + + + +template +template +inline +itpp::Vec +conv_to< itpp::Vec >::from(const Base& in, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + const unwrap tmp( in.get_ref() ); + const Mat& X = tmp.M; + + itpp::Vec out(X.n_elem); + + arrayops::convert_cx( out._data(), X.memptr(), X.n_elem ); + + return out; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_cor.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_cor.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,48 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_cor +//! @{ + + + +template +inline +const Op +cor(const Base& X, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (norm_type > 1), "cor(): norm_type must be 0 or 1"); + + return Op(X.get_ref(), norm_type, 0); + } + + + +template +inline +const Glue +cor(const Base& A, const Base& B, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (norm_type > 1), "cor(): norm_type must be 0 or 1"); + + return Glue(A.get_ref(), B.get_ref(), norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_cov.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_cov.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,48 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_cov +//! @{ + + + +template +inline +const Op +cov(const Base& X, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (norm_type > 1), "cov(): norm_type must be 0 or 1"); + + return Op(X.get_ref(), norm_type, 0); + } + + + +template +inline +const Glue +cov(const Base& A, const Base& B, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (norm_type > 1), "cov(): norm_type must be 0 or 1"); + + return Glue(A.get_ref(), B.get_ref(), norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_cross.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_cross.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,32 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_cross +//! @{ + + + +//! cross product (only valid for 3 dimensional vectors) +template +inline +const Glue +cross(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return Glue(X.get_ref(), Y.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_cumsum.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_cumsum.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,103 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_cumsum +//! @{ + + + +template +arma_inline +const Op +cumsum(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const Row& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const Col& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const subview_row& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const subview_col& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const diagview& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +template +arma_inline +const Op, op_cumsum_vec> +cumsum(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + return Op, op_cumsum_vec>(A); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_det.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_det.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,124 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_det +//! @{ + + + +//! determinant of mat +template +inline +arma_warn_unused +typename T1::elem_type +det + ( + const Base& X, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return auxlib::det(X, slow); + } + + + +//! determinant of diagmat +template +inline +arma_warn_unused +typename T1::elem_type +det + ( + const Op& X, + const bool slow = false + ) + { + arma_extra_debug_sigprint(); + arma_ignore(slow); + + typedef typename T1::elem_type eT; + + const diagmat_proxy A(X.m); + + const uword A_n_elem = A.n_elem; + + eT val = eT(1); + + for(uword i=0; i +inline +arma_warn_unused +typename T1::elem_type +det + ( + const Op& in, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + eT tmp = det(in.m, slow); + arma_warn( (tmp == eT(0)), "det(): warning: denominator is zero" ); + + return eT(1) / tmp; + } + + + +//! determinant of trans(A) +template +inline +arma_warn_unused +typename T1::elem_type +det + ( + const Op& in, + const bool slow = false, + const typename arma_blas_type_only::result* junk1 = 0, + const typename arma_not_cx::result* junk2 = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + return det(X, slow); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_diagmat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_diagmat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_diagmat +//! @{ + + +//! interpret a matrix or a vector as a diagonal matrix (i.e. off-diagonal entries are zero) +template +arma_inline +const Op +diagmat(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +// TODO: +// create "op_diagmat2", to allow placement of vector onto a sub- or super- diagonal. +// op_diagmat2 is required, as other code assumes that op_diagmat indicates only the main diagonal) + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_diagvec.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_diagvec.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,31 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_diagvec +//! @{ + + +//! extract a diagonal from a matrix +template +arma_inline +const Op +diagvec(const Base& X, const sword diag_id = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), ((diag_id < 0) ? -diag_id : diag_id), ((diag_id < 0) ? 1 : 0) ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_dot.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_dot.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,118 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_dot +//! @{ + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +dot + ( + const Base& A, + const Base& B + ) + { + arma_extra_debug_sigprint(); + + return op_dot::apply(A,B); + } + + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +norm_dot + ( + const Base& A, + const Base& B, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + return op_norm_dot::apply(A,B); + } + + + +// +// cdot + + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +cdot + ( + const Base& A, + const Base& B, + const typename arma_cx_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return op_cdot::apply(A,B); + } + + + +template +arma_inline +arma_warn_unused +typename T1::elem_type +cdot + ( + const Base& A, + const Base& B, + const typename arma_not_cx::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return op_dot::apply(A,B); + } + + + + +// convert dot(htrans(x), y) to cdot(x,y) + +template +arma_inline +arma_warn_unused +typename T1::elem_type +dot + ( + const Op& A, + const Base& B, + const typename arma_cx_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return cdot(A.m, B); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_eig.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_eig.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,310 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009 Edmund Highcock +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_eig +//! @{ + + +// +// symmetric/hermitian matrices +// + + +//! Eigenvalues of real/complex symmetric/hermitian matrix X +template +inline +bool +eig_sym + ( + Col& eigval, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + // unwrap_check not used as T1::elem_type and T1::pod_type may not be the same. + // furthermore, it doesn't matter if X is an alias of eigval, as auxlib::eig_sym() makes a copy of X + + const bool status = auxlib::eig_sym(eigval, X); + + if(status == false) + { + eigval.reset(); + arma_bad("eig_sym(): failed to converge", false); + } + + return status; + } + + + +//! Eigenvalues of real/complex symmetric/hermitian matrix X +template +inline +Col +eig_sym + ( + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + Col out; + const bool status = auxlib::eig_sym(out, X); + + if(status == false) + { + out.reset(); + arma_bad("eig_sym(): failed to converge"); + } + + return out; + } + + + +//! Eigenvalues and eigenvectors of real/complex symmetric/hermitian matrix X +template +inline +bool +eig_sym + ( + Col& eigval, + Mat& eigvec, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check( ( ((void*)(&eigval)) == ((void*)(&eigvec)) ), "eig_sym(): eigval is an alias of eigvec" ); + + const bool status = auxlib::eig_sym(eigval, eigvec, X); + + if(status == false) + { + eigval.reset(); + eigvec.reset(); + arma_bad("eig_sym(): failed to converge", false); + } + + return status; + } + + + +// +// general matrices +// + + + +//! Eigenvalues and eigenvectors (both left and right) of general real/complex square matrix X +template +inline +bool +eig_gen + ( + Col< std::complex >& eigval, + Mat& l_eigvec, + Mat& r_eigvec, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check + ( + ((&l_eigvec) == (&r_eigvec)), + "eig_gen(): l_eigvec is an alias of r_eigvec" + ); + + arma_debug_check + ( + ( + (((void*)(&eigval)) == ((void*)(&l_eigvec))) + || + (((void*)(&eigval)) == ((void*)(&r_eigvec))) + ), + "eig_gen(): eigval is an alias of l_eigvec or r_eigvec" + ); + + const bool status = auxlib::eig_gen(eigval, l_eigvec, r_eigvec, X, 'b'); + + if(status == false) + { + eigval.reset(); + l_eigvec.reset(); + r_eigvec.reset(); + arma_bad("eig_gen(): failed to converge", false); + } + + return status; + } + + + +//! Eigenvalues and eigenvectors of general real square matrix X. +//! Optional argument 'side' specifies which eigenvectors should be computed: +//! 'r' for right (default) and 'l' for left. +template +inline +bool +eig_gen + ( + Col< std::complex >& eigval, + Mat< std::complex >& eigvec, + const Base& X, + const char side = 'r', + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + //std::cout << "real" << std::endl; + + arma_debug_check( ( ((void*)(&eigval)) == ((void*)(&eigvec)) ), "eig_gen(): eigval is an alias of eigvec" ); + + Mat dummy_eigvec; + Mat tmp_eigvec; + + bool status; + + switch(side) + { + case 'r': + status = auxlib::eig_gen(eigval, dummy_eigvec, tmp_eigvec, X, side); + break; + + case 'l': + status = auxlib::eig_gen(eigval, tmp_eigvec, dummy_eigvec, X, side); + break; + + default: + arma_stop("eig_gen(): parameter 'side' is invalid"); + status = false; + } + + if(status == false) + { + eigval.reset(); + eigvec.reset(); + arma_bad("eig_gen(): failed to converge", false); + } + else + { + const uword n = eigval.n_elem; + + if(n > 0) + { + eigvec.set_size(n,n); + + for(uword j=0; j >( tmp_eigvec.col(j), tmp_eigvec.col(j+1) ); + // eigvec.col(j+1) = Mat< std::complex >( tmp_eigvec.col(j), -tmp_eigvec.col(j+1) ); + + for(uword i=0; i( tmp_eigvec.at(i,j), tmp_eigvec.at(i,j+1) ); + eigvec.at(i,j+1) = std::complex( tmp_eigvec.at(i,j), -tmp_eigvec.at(i,j+1) ); + } + + ++j; + } + else + { + // eigvec.col(i) = tmp_eigvec.col(i); + + for(uword i=0; i(tmp_eigvec.at(i,j), eT(0)); + } + + } + } + } + } + + return status; + } + + + +//! Eigenvalues and eigenvectors of general complex square matrix X +//! Optional argument 'side' specifies which eigenvectors should be computed: +//! 'r' for right (default) and 'l' for left. +template +inline +bool +eig_gen + ( + Col >& eigval, + Mat >& eigvec, + const Base, T1>& X, + const char side = 'r', + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + //std::cout << "complex" << std::endl; + + arma_debug_check( ( ((void*)(&eigval)) == ((void*)(&eigvec)) ), "eig_gen(): eigval is an alias of eigvec" ); + + Mat< std::complex > dummy_eigvec; + + bool status; + + switch(side) + { + case 'r': + status = auxlib::eig_gen(eigval, dummy_eigvec, eigvec, X, side); + break; + + case 'l': + status = auxlib::eig_gen(eigval, eigvec, dummy_eigvec, X, side); + break; + + default: + arma_stop("eig_gen(): parameter 'side' is invalid"); + status = false; + } + + if(status == false) + { + eigval.reset(); + eigvec.reset(); + arma_bad("eig_gen(): failed to converge", false); + } + + return status; + } + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_elem.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_elem.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,625 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_elem +//! @{ + + + +// +// find + +template +inline +const mtOp +find(const Base& X, const uword k = 0, const char* direction = "first") + { + arma_extra_debug_sigprint(); + + const char sig = direction[0]; + + arma_debug_check + ( + (sig != 'f' && sig != 'F' && sig != 'l' && sig != 'L'), + "find(): 3rd input argument must be \"first\" or \"last\"" + ); + + const uword type = (sig == 'f' || sig == 'F') ? 0 : 1; + + return mtOp(X.get_ref(), k, type); + } + + + +// +// real + +template +arma_inline +const T1& +real(const Base& X) + { + arma_extra_debug_sigprint(); + + return X.get_ref(); + } + + + +template +arma_inline +const T1& +real(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + return X.get_ref(); + } + + + +template +inline +const mtOp +real(const Base, T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp( X.get_ref() ); + } + + + +template +inline +const mtOpCube +real(const BaseCube, T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube( X.get_ref() ); + } + + + +// +// imag + +template +inline +const Gen +imag(const Base& X) + { + arma_extra_debug_sigprint(); + + const Proxy A(X.get_ref()); + + return Gen(A.get_n_rows(), A.get_n_cols()); + } + + + +template +inline +const GenCube +imag(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + const ProxyCube A(X.get_ref()); + + return GenCube(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + } + + + +template +inline +const mtOp +imag(const Base, T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp( X.get_ref() ); + } + + + +template +inline +const mtOpCube +imag(const BaseCube,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube( X.get_ref() ); + } + + + +// +// log + +template +arma_inline +const eOp +log(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +log(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// log2 + +template +arma_inline +const eOp +log2(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +log2(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// log10 + +template +arma_inline +const eOp +log10(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +log10(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// exp + +template +arma_inline +const eOp +exp(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +exp(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// exp2 + +template +arma_inline +const eOp +exp2(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +exp2(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// exp10 + +template +arma_inline +const eOp +exp10(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +exp10(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// abs + + +template +arma_inline +const eOp +abs(const Base& X, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return eOp(X.get_ref()); + } + + + +template +arma_inline +const eOpCube +abs(const BaseCube& X, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return eOpCube(X.get_ref()); + } + + + +template +inline +const mtOp +abs(const Base, T1>& X, const typename arma_cx_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return mtOp( X.get_ref() ); + } + + + +template +inline +const mtOpCube +abs(const BaseCube< std::complex,T1>& X, const typename arma_cx_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return mtOpCube( X.get_ref() ); + } + + + +// +// square + +template +arma_inline +const eOp +square(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +square(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// sqrt + +template +arma_inline +const eOp +sqrt(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +sqrt(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// conj + +template +arma_inline +const T1& +conj(const Base& A) + { + arma_extra_debug_sigprint(); + + return A.get_ref(); + } + + + +template +arma_inline +const T1& +conj(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return A.get_ref(); + } + + + +template +arma_inline +const eOp +conj(const Base,T1>& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +conj(const BaseCube,T1>& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +template +arma_inline +const T1& +conj(const eOp& A) + { + arma_extra_debug_sigprint(); + + return A.m; + } + + + +template +arma_inline +const T1& +conj(const eOpCube& A) + { + arma_extra_debug_sigprint(); + + return A.m; + } + + + +// TODO: this needs a more elaborate template restriction mechanism to work properly, +// i.e. an overloaded version of thus function should do nothing if the input type is non-complex +// +// //! the conjugate of the transpose of a complex matrix is the same as the hermitian transpose +// template +// arma_inline +// const Op +// conj(const Op& A) +// { +// arma_extra_debug_sigprint(); +// +// return Op(A.m); +// } + + + +// pow + +template +arma_inline +const eOp +pow(const Base& A, const typename T1::elem_type exponent) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref(), exponent); + } + + + +template +arma_inline +const eOpCube +pow(const BaseCube& A, const typename T1::elem_type exponent) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref(), exponent); + } + + + +// pow, specialised handling (non-complex exponent for complex matrices) + +template +arma_inline +const eOp +pow(const Base& A, const typename T1::elem_type::value_type exponent) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + return eOp(A.get_ref(), eT(exponent)); + } + + + +template +arma_inline +const eOpCube +pow(const BaseCube& A, const typename T1::elem_type::value_type exponent) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + return eOpCube(A.get_ref(), eT(exponent)); + } + + + +// +// floor + +template +arma_inline +const eOp +floor(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +floor(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// ceil + +template +arma_inline +const eOp +ceil(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +ceil(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_eps.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_eps.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,108 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup fn_eps +//! @{ + + + +//! \brief +//! eps version for non-complex matrices and vectors +template +inline +const eOp +eps(const Base& X, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + return eOp(X.get_ref()); + } + + + +//! \brief +//! eps version for complex matrices and vectors +template +inline +Mat< typename T1::pod_type > +eps(const Base< std::complex, T1>& X, const typename arma_cx_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + typedef typename T1::pod_type T; + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + Mat out(A.n_rows, A.n_cols); + + T* out_mem = out.memptr(); + const eT* A_mem = A.memptr(); + const uword n_elem = A.n_elem; + + for(uword i=0; i +arma_inline +arma_warn_unused +typename arma_integral_only::result +eps(const eT& x) + { + arma_ignore(x); + + return eT(0); + } + + + +template +arma_inline +arma_warn_unused +typename arma_float_only::result +eps(const eT& x) + { + return eop_aux::direct_eps(x); + } + + + +template +arma_inline +arma_warn_unused +typename arma_float_only::result +eps(const std::complex& x) + { + return eop_aux::direct_eps(x); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_eye.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_eye.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,43 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_eye +//! @{ + + + +arma_inline +const Gen +eye(const uword n_rows, const uword n_cols) + { + arma_extra_debug_sigprint(); + + return Gen(n_rows, n_cols); + } + + + +template +arma_inline +const Gen +eye(const uword n_rows, const uword n_cols, const typename arma_Mat_Col_Row_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Gen(n_rows, n_cols); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_flip.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_flip.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,43 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_flip +//! @{ + + + +template +arma_inline +const Op +flipud(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +template +arma_inline +const Op +fliplr(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_inv.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_inv.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,120 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_inv +//! @{ + + + +//! delayed matrix inverse (general matrices) +template +arma_inline +const Op +inv + ( + const Base& X, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Op(X.get_ref(), ((slow == false) ? 0 : 1), 0); + } + + + +//! remove the inverse operation if applied twice consecutively +template +arma_inline +const T1& +inv(const Op& X, const bool slow = false) + { + arma_extra_debug_sigprint(); + arma_ignore(slow); + + return X.m; + } + + + +//! delayed matrix inverse (triangular matrices) +template +arma_inline +const Op +inv + ( + const Op& X, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(slow); + arma_ignore(junk); + + return Op(X.m, X.aux_uword_a, 0); + } + + + +//! delayed matrix inverse (symmetric positive definite matrices) +template +arma_inline +const Op +inv + ( + const Op& X, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(slow); + arma_ignore(junk); + + return Op(X.m, 0, 0); + } + + + +template +inline +bool +inv + ( + Mat& out, + const Base& X, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + try + { + out = inv(X,slow); + } + catch(std::runtime_error&) + { + return false; + } + + return true; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_join.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_join.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,55 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_join +//! @{ + + + +template +inline +const Glue +join_cols(const Base& A, const Base& B) + { + arma_extra_debug_sigprint(); + + return Glue(A.get_ref(), B.get_ref(), 0); + } + + + +template +inline +const Glue +join_rows(const Base& A, const Base& B) + { + arma_extra_debug_sigprint(); + + return Glue(A.get_ref(), B.get_ref(), 1); + } + + + +template +inline +const GlueCube +join_slices(const BaseCube& A, const BaseCube& B) + { + arma_extra_debug_sigprint(); + + return GlueCube(A.get_ref(), B.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_kron.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_kron.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,93 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_kron +//! @{ + + + +//! \brief +//! kronecker product of two matrices, +//! with the matrices having the same element type +template +arma_inline +const Glue +kron(const Base& A, const Base& B) + { + arma_extra_debug_sigprint(); + + return Glue(A.get_ref(), B.get_ref()); + } + + + +//! \brief +//! kronecker product of two matrices, +//! with the matrices having different element types +template +inline +Mat::eT> +kron(const Base,T1>& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT1; + + promote_type::check(); + + const unwrap tmp1(X.get_ref()); + const unwrap tmp2(Y.get_ref()); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + Mat out; + + glue_kron::direct_kron(out, A, B); + + return out; + } + + + +//! \brief +//! kronecker product of two matrices, +//! with the matrices having different element types +template +inline +Mat::eT> +kron(const Base& X, const Base,T2>& Y) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT2; + + promote_type::check(); + + const unwrap tmp1(X.get_ref()); + const unwrap tmp2(Y.get_ref()); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + Mat out; + + glue_kron::direct_kron(out, A, B); + + return out; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_log_det.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_log_det.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,87 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_log_det +//! @{ + + + +//! log determinant of mat +template +inline +bool +log_det + ( + typename T1::elem_type& out_val, + typename T1::pod_type& out_sign, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return auxlib::log_det(out_val, out_sign, X); + } + + + +template +inline +void +log_det + ( + typename T1::elem_type& out_val, + typename T1::pod_type& out_sign, + const Op& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const diagmat_proxy A(X.m); + + const uword N = A.n_elem; + + if(N == 0) + { + out_val = eT(0); + out_sign = T(1); + + return; + } + + const eT x = A[0]; + + T sign = (is_complex::value == false) ? ( (access::tmp_real(x) < T(0)) ? -1 : +1 ) : +1; + eT val = (is_complex::value == false) ? std::log( (access::tmp_real(x) < T(0)) ? x*T(-1) : x ) : std::log(x); + + for(uword i=1; i::value == false) ? ( (access::tmp_real(x) < T(0)) ? -1 : +1 ) : +1; + val += (is_complex::value == false) ? std::log( (access::tmp_real(x) < T(0)) ? x*T(-1) : x ) : std::log(x); + } + + out_val = val; + out_sign = sign; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_lu.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_lu.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,83 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_lu +//! @{ + + + +//! immediate lower upper decomposition, permutation info is embedded into L (similar to Matlab/Octave) +template +inline +bool +lu + ( + Mat& L, + Mat& U, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check( (&L == &U), "lu(): L and U are the same object"); + + const bool status = auxlib::lu(L, U, X); + + if(status == false) + { + L.reset(); + U.reset(); + arma_bad("lu(): failed to converge", false); + } + + return status; + } + + + +//! immediate lower upper decomposition, also providing the permutation matrix +template +inline +bool +lu + ( + Mat& L, + Mat& U, + Mat& P, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check( ( (&L == &U) || (&L == &P) || (&U == &P) ), "lu(): two or more output objects are the same object"); + + const bool status = auxlib::lu(L, U, P, X); + + if(status == false) + { + L.reset(); + U.reset(); + P.reset(); + arma_bad("lu(): failed to converge", false); + } + + return status; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_max.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_max.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,192 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_max +//! @{ + + +//! \brief +//! Delayed 'maximum values' operation. +//! The dimension, along which the maxima are found, is set via 'dim'. +//! For dim = 0, the maximum value of each column is found (i.e. searches by traversing across rows). +//! For dim = 1, the maximum value of each row is found (i.e. searches by traversing across columns). +//! The default is dim = 0. + +template +arma_inline +const Op +max(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + +//! Immediate 'find the maximum value in a row vector' operation +template +inline +arma_warn_unused +eT +max(const Row& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(A.mem, A_n_elem); + } + + + +//! Immediate 'find the maximum value in a column vector' operation +template +inline +arma_warn_unused +eT +max(const Col& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(A.mem, A_n_elem); + } + + + +//! \brief +//! Immediate 'find maximum value' operation, +//! invoked, for example, by: max(max(A)) +template +inline +arma_warn_unused +typename T1::elem_type +max(const Op& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("max(): two consecutive max() calls detected"); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(in.m); + const Mat& X = tmp1.M; + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(X.mem, X_n_elem); + } + + + +template +arma_inline +const Op< Op, op_max> +max(const Op& in, const uword dim) + { + arma_extra_debug_sigprint(); + + return Op< Op, op_max>(in, dim, 0); + } + + + +template +inline +arma_warn_unused +eT +max(const subview_row& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(A); + } + + + +template +inline +arma_warn_unused +eT +max(const subview_col& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(A.colptr(0), A.n_rows); + } + + + +template +inline +arma_warn_unused +eT +max(const Op, op_max>& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("max(): two consecutive max() calls detected"); + + const subview& X = in.m; + + arma_debug_check( (X.n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(X); + } + + + +template +inline +arma_warn_unused +eT +max(const diagview& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(A); + } + + + +template +inline +arma_warn_unused +eT +max(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + const Mat X(A); + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "max(): given object has no elements" ); + + return op_max::direct_max(X.mem, X_n_elem); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_mean.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_mean.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,189 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_mean +//! @{ + + + +template +arma_inline +const Op +mean(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + + +//! Immediate 'find the mean value of a row vector' operation +template +inline +arma_warn_unused +eT +mean(const Row& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(A.mem, A_n_elem); + } + + + +//! Immediate 'find the mean value of a column vector' operation +template +inline +arma_warn_unused +eT +mean(const Col& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(A.mem, A_n_elem); + } + + + +//! \brief +//! Immediate 'find mean value' operation, +//! invoked, for example, by: mean(mean(A)) +template +inline +arma_warn_unused +typename T1::elem_type +mean(const Op& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("mean(): two consecutive mean() calls detected"); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(in.m); + const Mat& X = tmp1.M; + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(X.mem, X_n_elem); + } + + + +template +arma_inline +const Op< Op, op_mean> +mean(const Op& in, const uword dim) + { + arma_extra_debug_sigprint(); + + return Op< Op, op_mean>(in, dim, 0); + } + + + +template +inline +arma_warn_unused +eT +mean(const subview_row& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "mean(): given object has no elements" ); + + const eT mu = accu(A) / eT(A.n_cols); + + return is_finite(mu) ? mu : op_mean::direct_mean_robust(A); + } + + + +template +inline +arma_warn_unused +eT +mean(const subview_col& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(A.colptr(0), A.n_rows); + } + + + +template +inline +arma_warn_unused +eT +mean(const Op, op_mean>& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("mean(): two consecutive mean() calls detected"); + + const subview& X = in.m; + + arma_debug_check( (X.n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(X); + } + + + +template +inline +arma_warn_unused +eT +mean(const diagview& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(A); + } + + + +template +inline +arma_warn_unused +eT +mean(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + const Mat X(A); + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "mean(): given object has no elements" ); + + return op_mean::direct_mean(X.mem, X_n_elem); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_median.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_median.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,231 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_median +//! @{ + + +template +arma_inline +const Op +median(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + + +//! Immediate 'find the median value of a row vector' operation +template +inline +arma_warn_unused +eT +median(const Row& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "median(): given object has no elements" ); + + return op_median::direct_median(A.mem, A_n_elem); + } + + + +//! Immediate 'find the median value of a column vector' operation +template +inline +arma_warn_unused +eT +median(const Col& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "median(): given object has no elements" ); + + return op_median::direct_median(A.mem, A_n_elem); + } + + + +//! Immediate 'find the median value of a row vector' operation (complex number version) +template +inline +arma_warn_unused +std::complex +median(const Row< std::complex >& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "median(): given object has no elements" ); + + uword index1; + uword index2; + op_median::direct_cx_median_index(index1, index2, A.mem, A_n_elem); + + return (index1 == index2) ? A.mem[index1] : op_median::robust_mean( A.mem[index1], A.mem[index2] ); + } + + + +//! Immediate 'find the median value of a column vector' operation (complex number version) +template +inline +arma_warn_unused +std::complex +median(const Col< std::complex >& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "median(): given object has no elements" ); + + uword index1; + uword index2; + op_median::direct_cx_median_index(index1, index2, A.mem, A_n_elem); + + return (index1 == index2) ? A.mem[index1] : op_median::robust_mean( A.mem[index1], A.mem[index2] ); + } + + + +//! find the median value of a subview_row +template +inline +arma_warn_unused +eT +median(const subview_row& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + return op_median::direct_median(A); + } + + + +//! find the median value of a subview_col +template +inline +arma_warn_unused +eT +median(const subview_col& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + return op_median::direct_median(A.colptr(0), A.n_rows); + } + + + +//! find the median value of a subview_row (complex number version) +template +inline +arma_warn_unused +std::complex +median(const subview_row< std::complex >& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + uword index1; + uword index2; + op_median::direct_cx_median_index(index1, index2, A); + + return (index1 == index2) ? A[index1] : op_median::robust_mean(A[index1], A[index2]); + } + + + +//! find the median value of a subview_col (complex number version) +template +inline +arma_warn_unused +std::complex +median(const subview_col< std::complex >& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + uword index1; + uword index2; + op_median::direct_cx_median_index(index1, index2, A); + + return (index1 == index2) ? A[index1] : op_median::robust_mean(A[index1], A[index2]); + } + + + +template +inline +arma_warn_unused +eT +median(const diagview& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + return op_median::direct_median(A); + } + + + +template +inline +arma_warn_unused +std::complex +median(const diagview< std::complex >& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "median(): given object has no elements" ); + + uword index1; + uword index2; + op_median::direct_cx_median_index(index1, index2, A); + + return (index1 == index2) ? A[index1] : op_median::robust_mean(A[index1], A[index2]); + } + + + +template +inline +arma_warn_unused +eT +median(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + const Col X(A); + + return median(X); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_min.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_min.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,191 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_min +//! @{ + +//! \brief +//! Delayed 'minimum values' operation. +//! The dimension, along which the minima are found, is set via 'dim'. +//! For dim = 0, the minimum value of each column is found (i.e. searches by traversing across rows). +//! For dim = 1, the minimum value of each row is found (i.e. searches by traversing across columns). +//! The default is dim = 0. + +template +arma_inline +const Op +min(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + +//! Immediate 'find the minimum value in a row vector' operation +template +inline +arma_warn_unused +eT +min(const Row& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(A.mem, A_n_elem); + } + + + +//! Immediate 'find the minimum value in a column vector' +template +inline +arma_warn_unused +eT +min(const Col& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(A.mem, A_n_elem); + } + + + +//! \brief +//! Immediate 'find minimum value' operation, +//! invoked, for example, by: min(min(A)) +template +inline +arma_warn_unused +typename T1::elem_type +min(const Op& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("min(): two consecutive min() calls detected"); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(in.m); + const Mat& X = tmp1.M; + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(X.mem, X_n_elem); + } + + + +template +inline +const Op< Op, op_min> +min(const Op& in, const uword dim) + { + arma_extra_debug_sigprint(); + + return Op< Op, op_min>(in, dim, 0); + } + + + +template +inline +arma_warn_unused +eT +min(const subview_row& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(A); + } + + + +template +inline +arma_warn_unused +eT +min(const subview_col& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(A.colptr(0), A.n_rows); + } + + + +template +inline +arma_warn_unused +eT +min(const diagview& A) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(A); + } + + + +template +inline +arma_warn_unused +eT +min(const Op, op_min>& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("min(): two consecutive min() calls detected"); + + const subview& X = in.m; + + arma_debug_check( (X.n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(X); + } + + + +template +inline +arma_warn_unused +eT +min(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + const Mat X(A); + + const uword X_n_elem = X.n_elem; + + arma_debug_check( (X_n_elem == 0), "min(): given object has no elements" ); + + return op_min::direct_min(X.mem, X_n_elem); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_misc.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_misc.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,189 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_misc +//! @{ + + + +//! \brief +//! Generate a vector with 'num' elements. +//! The values of the elements linearly increase from 'start' upto (and including) 'end'. + +template +inline +vec_type +linspace + ( + const typename vec_type::pod_type start, + const typename vec_type::pod_type end, + const uword num = 100u, + const typename arma_Mat_Col_Row_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename vec_type::elem_type eT; + typedef typename vec_type::pod_type T; + + vec_type x; + + if(num >= 2) + { + x.set_size(num); + + eT* x_mem = x.memptr(); + + const uword num_m1 = num - 1; + + if(is_non_integral::value == true) + { + const T delta = (end-start)/T(num_m1); + + for(uword i=0; i= start) ? double(end-start)/double(num_m1) : -double(start-end)/double(num_m1); + + for(uword i=0; i(start, end, num); + } + + + +// +// log_add + +template +inline +typename arma_float_only::result +log_add(eT log_a, eT log_b) + { + if(log_a < log_b) + { + std::swap(log_a, log_b); + } + + const eT negdelta = log_b - log_a; + + if( (negdelta < Math::log_min()) || (arma_isfinite(negdelta) == false) ) + { + return log_a; + } + else + { + #if defined(ARMA_HAVE_LOG1P) + return (log_a + log1p(std::exp(negdelta))); + #else + return (log_a + std::log(1.0 + std::exp(negdelta))); + #endif + } + } + + + +template +arma_inline +arma_warn_unused +bool +is_finite(const eT x, const typename arma_scalar_only::result* junk = 0) + { + arma_ignore(junk); + + return arma_isfinite(x); + } + + + +template +inline +arma_warn_unused +bool +is_finite(const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + return A.is_finite(); + } + + + +template +inline +arma_warn_unused +bool +is_finite(const BaseCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_cube tmp(X.get_ref()); + const Cube& A = tmp.M; + + return A.is_finite(); + } + + + +template +arma_inline +Op +sympd(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_norm.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_norm.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,510 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_norm +//! @{ + + + +template +arma_hot +inline +typename T1::pod_type +arma_vec_norm_1(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + T acc = T(0); + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = A.get_ea(); + + const uword N = A.get_n_elem(); + + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +typename T1::pod_type +arma_vec_norm_2(const Proxy& A, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::pod_type T; + + T acc = T(0); + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = A.get_ea(); + + const uword N = A.get_n_elem(); + + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +typename T1::pod_type +arma_vec_norm_2(const Proxy& A, const typename arma_cx_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::pod_type T; + + T acc = T(0); + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = A.get_ea(); + + const uword N = A.get_n_elem(); + + for(uword i=0; i +arma_hot +inline +typename T1::pod_type +arma_vec_norm_k(const Proxy& A, const int k) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + T acc = T(0); + + if(Proxy::prefer_at_accessor == false) + { + typename Proxy::ea_type P = A.get_ea(); + + const uword N = A.get_n_elem(); + + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +typename T1::pod_type +arma_vec_norm_max(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + typedef typename Proxy::ea_type ea_type; + + ea_type P = A.get_ea(); + const uword N = A.get_n_elem(); + + T max_val = (N != 1) ? priv::most_neg() : std::abs(P[0]); + + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +typename T1::pod_type +arma_vec_norm_min(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + typedef typename Proxy::ea_type ea_type; + + ea_type P = A.get_ea(); + const uword N = A.get_n_elem(); + + T min_val = (N != 1) ? priv::most_pos() : std::abs(P[0]); + + uword i,j; + + for(i=0, j=1; j tmp_i) { min_val = tmp_i; } + if(min_val > tmp_j) { min_val = tmp_j; } + } + + if(i < N) + { + const T tmp_i = std::abs(P[i]); + + if(min_val > tmp_i) { min_val = tmp_i; } + } + + return min_val; + } + + + +template +inline +typename T1::pod_type +arma_mat_norm_1(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const unwrap::stored_type> tmp(A.Q); + const Mat& X = tmp.M; + + // TODO: this can be sped up with a dedicated implementation + return as_scalar( max( sum(abs(X)), 1) ); + } + + + +template +inline +typename T1::pod_type +arma_mat_norm_2(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const unwrap::stored_type> tmp(A.Q); + const Mat& X = tmp.M; + + Col S; + svd(S, X); + + return (S.n_elem > 0) ? max(S) : T(0); + } + + + +template +inline +typename T1::pod_type +arma_mat_norm_inf(const Proxy& A) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const unwrap::stored_type> tmp(A.Q); + const Mat& X = tmp.M; + + // TODO: this can be sped up with a dedicated implementation + return as_scalar( max( sum(abs(X),1) ) ); + } + + + +template +inline +arma_warn_unused +typename T1::pod_type +norm + ( + const Base& X, + const uword k, + const typename arma_float_or_cx_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const Proxy A(X.get_ref()); + + if(A.get_n_elem() == 0) + { + return T(0); + } + + const bool is_vec = (A.get_n_rows() == 1) || (A.get_n_cols() == 1); + + if(is_vec == true) + { + switch(k) + { + case 1: + return arma_vec_norm_1(A); + break; + + case 2: + return arma_vec_norm_2(A); + break; + + default: + { + arma_debug_check( (k == 0), "norm(): k must be greater than zero" ); + return arma_vec_norm_k(A, int(k)); + } + } + } + else + { + switch(k) + { + case 1: + return arma_mat_norm_1(A); + break; + + case 2: + return arma_mat_norm_2(A); + break; + + default: + arma_stop("norm(): unsupported matrix norm type"); + return T(0); + } + } + } + + + +template +inline +arma_warn_unused +typename T1::pod_type +norm + ( + const Base& X, + const char* method, + const typename arma_float_or_cx_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + const Proxy A(X.get_ref()); + + if(A.get_n_elem() == 0) + { + return T(0); + } + + const char sig = method[0]; + const bool is_vec = (A.get_n_rows() == 1) || (A.get_n_cols() == 1); + + if(is_vec == true) + { + if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // max norm + { + return arma_vec_norm_max(A); + } + else + if(sig == '-') // min norm + { + return arma_vec_norm_min(A); + } + else + if( (sig == 'f') || (sig == 'F') ) + { + return arma_vec_norm_2(A); + } + else + { + arma_stop("norm(): unsupported vector norm type"); + return T(0); + } + } + else + { + if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // inf norm + { + return arma_mat_norm_inf(A); + } + else + if( (sig == 'f') || (sig == 'F') ) + { + return arma_vec_norm_2(A); + } + else + { + arma_stop("norm(): unsupported matrix norm type"); + return T(0); + } + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_ones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_ones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,99 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_ones +//! @{ + + + +arma_inline +const Gen +ones(const uword n_elem) + { + arma_extra_debug_sigprint(); + + return Gen(n_elem, 1); + } + + + +template +arma_inline +const Gen +ones(const uword n_elem, const arma_empty_class junk1 = arma_empty_class(), const typename arma_Mat_Col_Row_only::result* junk2 = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + if(is_Row::value == true) + { + return Gen(1, n_elem); + } + else + { + return Gen(n_elem, 1); + } + } + + + +arma_inline +const Gen +ones(const uword n_rows, const uword n_cols) + { + arma_extra_debug_sigprint(); + + return Gen(n_rows, n_cols); + } + + + +template +arma_inline +const Gen +ones(const uword n_rows, const uword n_cols, const typename arma_Mat_Col_Row_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Gen(n_rows, n_cols); + } + + + +arma_inline +const GenCube +ones(const uword n_rows, const uword n_cols, const uword n_slices) + { + arma_extra_debug_sigprint(); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +template +arma_inline +const GenCube +ones(const uword n_rows, const uword n_cols, const uword n_slices, const typename arma_Cube_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_pinv.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_pinv.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,66 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_pinv +//! @{ + + + +template +inline +const Op +pinv + ( + const Base& X, + const typename T1::elem_type tol = 0.0, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Op(X.get_ref(), tol); + } + + + +template +inline +bool +pinv + ( + Mat& out, + const Base& X, + const typename T1::elem_type tol = 0.0, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + try + { + out = pinv(X,tol); + } + catch(std::runtime_error&) + { + return false; + } + + return true; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_princomp.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_princomp.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,190 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_princomp +//! @{ + + + +//! \brief +//! principal component analysis -- 4 arguments version +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +//! tsquared_out -> Hotelling's T^2 statistic +template +inline +bool +princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + Col& tsquared_out, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + const bool status = op_princomp::direct_princomp(coeff_out, score_out, latent_out, tsquared_out, A); + + if(status == false) + { + coeff_out.reset(); + score_out.reset(); + latent_out.reset(); + tsquared_out.reset(); + + arma_bad("princomp(): failed to converge", false); + } + + return status; + } + + + +//! \brief +//! principal component analysis -- 3 arguments version +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +template +inline +bool +princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + const bool status = op_princomp::direct_princomp(coeff_out, score_out, latent_out, A); + + if(status == false) + { + coeff_out.reset(); + score_out.reset(); + latent_out.reset(); + + arma_bad("princomp(): failed to converge", false); + } + + return status; + } + + + +//! \brief +//! principal component analysis -- 2 arguments version +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +template +inline +bool +princomp + ( + Mat& coeff_out, + Mat& score_out, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + const bool status = op_princomp::direct_princomp(coeff_out, score_out, A); + + if(status == false) + { + coeff_out.reset(); + score_out.reset(); + + arma_bad("princomp(): failed to converge", false); + } + + return status; + } + + + +//! \brief +//! principal component analysis -- 1 argument version +//! coeff_out -> principal component coefficients +template +inline +bool +princomp + ( + Mat& coeff_out, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + const bool status = op_princomp::direct_princomp(coeff_out, A); + + if(status == false) + { + coeff_out.reset(); + + arma_bad("princomp(): failed to converge", false); + } + + return status; + } + + + +template +inline +const Op +princomp + ( + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_prod.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_prod.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,185 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_prod +//! @{ + + +//! \brief +//! Delayed product of elements of a matrix along a specified dimension (either rows or columns). +//! The result is stored in a dense matrix that has either one column or one row. +//! For dim = 0, find the sum of each column (i.e. traverse across rows) +//! For dim = 1, find the sum of each row (i.e. traverse across columns) +//! The default is dim = 0. +//! NOTE: this function works differently than in Matlab/Octave. + +template +arma_inline +const Op +prod(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + + +//! \brief +//! Immediate 'product of all values' operation for a row vector +template +inline +arma_warn_unused +eT +prod(const Row& X) + { + arma_extra_debug_sigprint(); + + return arrayops::product(X.memptr(), X.n_elem); + } + + + +//! \brief +//! Immediate 'product of all values' operation for a column vector +template +inline +arma_warn_unused +eT +prod(const Col& X) + { + arma_extra_debug_sigprint(); + + return arrayops::product(X.memptr(), X.n_elem); + } + + + +//! \brief +//! Immediate 'product of all values' operation, +//! invoked, for example, by: prod(prod(A)) + +template +inline +typename T1::elem_type +prod(const Op& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("prod(): two consecutive prod() calls detected"); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + return arrayops::product( X.memptr(), X.n_elem ); + } + + + +template +inline +const Op, op_prod> +prod(const Op& in, const uword dim) + { + arma_extra_debug_sigprint(); + + return Op, op_prod>(in, dim, 0); + } + + + +//! product of all values of a subview_row +template +inline +arma_warn_unused +eT +prod(const subview_row& S) + { + arma_extra_debug_sigprint(); + + const Mat& X = S.m; + + const uword n_elem = S.n_elem; + const uword row = S.aux_row1; + const uword start_col = S.aux_col1; + const uword end_col_plus_1 = start_col + S.n_cols; + + eT val = eT(1); + + if(n_elem > 0) + { + for(uword col=start_col; col +inline +arma_warn_unused +eT +prod(const subview_col& S) + { + arma_extra_debug_sigprint(); + + return (S.n_elem > 0) ? arrayops::product( S.colptr(0), S.n_rows ) : eT(1); + } + + + +//! product of all values of a diagview +template +arma_warn_unused +inline +eT +prod(const diagview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + eT val = eT(1); + + for(uword i=0; i +inline +arma_warn_unused +eT +prod(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + const Col X(A); + + return prod(X); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_qr.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_qr.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,50 @@ +// Copyright (C) 2009-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_qr +//! @{ + + + +//! QR decomposition +template +inline +bool +qr + ( + Mat& Q, + Mat& R, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check( (&Q == &R), "qr(): Q and R are the same object"); + + const bool status = auxlib::qr(Q, R, X); + + if(status == false) + { + Q.reset(); + R.reset(); + arma_bad("qr(): failed to converge", false); + } + + return status; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_randn.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_randn.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,119 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_randn +//! @{ + + +inline +double +randn() + { + return double(eop_aux_randn()); + } + + +template +inline +typename arma_scalar_only::result +randn() + { + return eT(eop_aux_randn()); + } + + + +//! Generate a vector with all elements set to random values with a gaussian distribution (zero mean, unit variance) +arma_inline +const Gen +randn(const uword n_elem) + { + arma_extra_debug_sigprint(); + + return Gen(n_elem, 1); + } + + + +template +arma_inline +const Gen +randn(const uword n_elem, const arma_empty_class junk1 = arma_empty_class(), const typename arma_Mat_Col_Row_only::result* junk2 = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + if(is_Row::value == true) + { + return Gen(1, n_elem); + } + else + { + return Gen(n_elem, 1); + } + } + + + +//! Generate a dense matrix with all elements set to random values with a gaussian distribution (zero mean, unit variance) +arma_inline +const Gen +randn(const uword n_rows, const uword n_cols) + { + arma_extra_debug_sigprint(); + + return Gen(n_rows, n_cols); + } + + + +template +arma_inline +const Gen +randn(const uword n_rows, const uword n_cols, const typename arma_Mat_Col_Row_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Gen(n_rows, n_cols); + } + + + +arma_inline +const GenCube +randn(const uword n_rows, const uword n_cols, const uword n_slices) + { + arma_extra_debug_sigprint(); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +template +arma_inline +const GenCube +randn(const uword n_rows, const uword n_cols, const uword n_slices, const typename arma_Cube_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + + arma_ignore(junk); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_randu.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_randu.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,118 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_randu +//! @{ + + +inline +double +randu() + { + return double(eop_aux_randu()); + } + + +template +inline +typename arma_scalar_only::result +randu() + { + return eT(eop_aux_randu()); + } + + + +//! Generate a vector with all elements set to random values in the [0,1] interval (uniform distribution) +arma_inline +const Gen +randu(const uword n_elem) + { + arma_extra_debug_sigprint(); + + return Gen(n_elem, 1); + } + + + +template +arma_inline +const Gen +randu(const uword n_elem, const arma_empty_class junk1 = arma_empty_class(), const typename arma_Mat_Col_Row_only::result* junk2 = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + if(is_Row::value == true) + { + return Gen(1, n_elem); + } + else + { + return Gen(n_elem, 1); + } + } + + + +//! Generate a dense matrix with all elements set to random values in the [0,1] interval (uniform distribution) +arma_inline +const Gen +randu(const uword n_rows, const uword n_cols) + { + arma_extra_debug_sigprint(); + + return Gen(n_rows, n_cols); + } + + + +template +arma_inline +const Gen +randu(const uword n_rows, const uword n_cols, const typename arma_Mat_Col_Row_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Gen(n_rows, n_cols); + } + + + +arma_inline +const GenCube +randu(const uword n_rows, const uword n_cols, const uword n_slices) + { + arma_extra_debug_sigprint(); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +template +arma_inline +const GenCube +randu(const uword n_rows, const uword n_cols, const uword n_slices, const typename arma_Cube_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_rank.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_rank.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,77 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_rank +//! @{ + + + +template +inline +arma_warn_unused +uword +rank + ( + const Base& X, + typename T1::pod_type tol = 0.0, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + typedef typename T1::pod_type T; + + uword X_n_rows; + uword X_n_cols; + Col s; + + const bool status = auxlib::svd(s, X, X_n_rows, X_n_cols); + const uword n_elem = s.n_elem; + + if(status == true) + { + if( (tol == T(0)) && (n_elem > 0) ) + { + tol = (std::max)(X_n_rows, X_n_cols) * eop_aux::direct_eps(max(s)); + } + + // count non zero valued elements in s + + const T* s_mem = s.memptr(); + uword count = 0; + + for(uword i=0; i tol) + { + ++count; + } + } + + return count; + } + else + { + arma_bad("rank(): failed to converge"); + + return uword(0); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_repmat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_repmat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,34 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup fn_repmat +//! @{ + + +//! \brief +//! delayed 'repeat matrix' construction of a matrix +template +arma_inline +const Op +repmat(const Base& A, const uword r, const uword c) + { + arma_extra_debug_sigprint(); + + return Op(A.get_ref(), r, c); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_reshape.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_reshape.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_reshape +//! @{ + + + +template +inline +const Op +reshape(const Base& X, const uword in_n_rows, const uword in_n_cols, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (dim > 1), "reshape(): dim must be 0 or 1"); + + typedef typename T1::elem_type eT; + + return Op(X.get_ref(), in_n_rows, in_n_cols, dim, 'j'); + } + + + +template +inline +const OpCube +reshape(const BaseCube& X, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (dim > 1), "reshape(): dim must be 0 or 1"); + + typedef typename T1::elem_type eT; + + return OpCube(X.get_ref(), in_n_rows, in_n_cols, in_n_slices, dim, 'j'); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_resize.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_resize.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,43 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_resize +//! @{ + + + +template +inline +const Op +resize(const Base& X, const uword in_n_rows, const uword in_n_cols) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), in_n_rows, in_n_cols); + } + + + +template +inline +const OpCube +resize(const BaseCube& X, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices) + { + arma_extra_debug_sigprint(); + + return OpCube(X.get_ref(), in_n_rows, in_n_cols, in_n_slices); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_shuffle.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_shuffle.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup fn_shuffle +//! @{ + +//! \brief +//! Shuffle the rows or the columns of a matrix or vector in random fashion. +//! If dim = 0, shuffle the columns (default operation). +//! If dim = 1, shuffle the rows. + +template +inline +const Op +shuffle(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (dim > 1), "shuffle(): dim must be 0 or 1"); + + return Op(X.get_ref(), dim, 0); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_solve.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_solve.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,95 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_solve +//! @{ + + + +//! Solve a system of linear equations, i.e., A*X = B, where X is unknown. +//! For a square matrix A, this function is conceptually the same as X = inv(A)*B, +//! but is done more efficiently. +//! The number of rows in A and B must be the same. +//! B can be either a column vector or a matrix. +//! This function will also try to provide approximate solutions +//! to under-determined as well as over-determined systems (non-square A matrices). + +template +inline +const Glue +solve + ( + const Base& A, + const Base& B, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Glue(A.get_ref(), B.get_ref(), ((slow == false) ? 0 : 1) ); + } + + + +template +inline +const Glue +solve + ( + const Op& A, + const Base& B, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(slow); + arma_ignore(junk); + + return Glue(A.m, B.get_ref(), A.aux_uword_a); + } + + + +template +inline +bool +solve + ( + Mat& out, + const Base& A, + const Base& B, + const bool slow = false, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + try + { + out = solve( A.get_ref(), B.get_ref(), slow ); + } + catch(std::runtime_error&) + { + return false; + } + + return true; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_sort.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_sort.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,58 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_sort +//! @{ + + +template +arma_inline +const Op +sort(const Base& X, const uword sort_type = 0, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), sort_type, dim); + } + + + +template +arma_inline +const Op, op_sort> +sort(const Col& X, const uword sort_type = 0) + { + arma_extra_debug_sigprint(); + + const uword dim = 0; + + return Op, op_sort>(X, sort_type, dim); + } + + + +template +arma_inline +const Op, op_sort> +sort(const Row& X, const uword sort_type = 0) + { + arma_extra_debug_sigprint(); + + const uword dim = 1; + + return Op, op_sort>(X, sort_type, dim); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_sort_index.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_sort_index.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,125 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_sort_index +//! @{ + + + + +template +struct arma_sort_index_packet_ascend + { + T1 val; + T2 index; + }; + + + +template +struct arma_sort_index_packet_descend + { + T1 val; + T2 index; + }; + + + +template +inline +bool +operator< (const arma_sort_index_packet_ascend& A, const arma_sort_index_packet_ascend& B) + { + return A.val < B.val; + } + + + +template +inline +bool +operator< (const arma_sort_index_packet_descend& A, const arma_sort_index_packet_descend& B) + { + return A.val > B.val; + } + + + +template +void +inline +sort_index_helper(umat_elem_type* out_mem, std::vector& packet_vec, const eT* in_mem) + { + arma_extra_debug_sigprint(); + + const uword n_elem = packet_vec.size(); + + for(uword i=0; i +inline +umat +sort_index(const Base& X, const uword sort_type = 0) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + arma_type_check(( is_complex::value == true )); + + const unwrap tmp(X.get_ref()); + const Mat& A = tmp.M; + + if(A.is_empty() == true) + { + return umat(); + } + + arma_debug_check( (A.is_vec() == false), "sort_index(): currently only handles vectors"); + + typedef typename umat::elem_type out_elem_type; + + umat out(A.n_rows, A.n_cols); + + if(sort_type == 0) + { + std::vector< arma_sort_index_packet_ascend > packet_vec(A.n_elem); + + sort_index_helper(out.memptr(), packet_vec, A.mem); + } + else + { + std::vector< arma_sort_index_packet_descend > packet_vec(A.n_elem); + + sort_index_helper(out.memptr(), packet_vec, A.mem); + } + + return out; + } + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_stddev.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_stddev.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,130 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_stddev +//! @{ + + + +template +inline +const mtOp +stddev(const Base& X, const uword norm_type = 0, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), norm_type, dim); + } + + + +//! Immediate 'find the standard deviation of a row vector' operation +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const Row& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "stddev(): given object has no elements" ); + + return std::sqrt( op_var::direct_var(A.mem, A_n_elem, norm_type) ); + } + + + +//! Immediate 'find the standard deviation of a column vector' operation +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const Col& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "stddev(): given object has no elements" ); + + return std::sqrt( op_var::direct_var(A.mem, A_n_elem, norm_type) ); + } + + + +//! find the standard deviation of a subview_row +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const subview_row& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "stddev(): given object has no elements" ); + + return std::sqrt( op_var::direct_var(A, norm_type) ); + } + + + +//! find the standard deviation of a subview_col +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const subview_col& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "stddev(): given object has no elements" ); + + return std::sqrt( op_var::direct_var(A.colptr(0), A.n_rows, norm_type) ); + } + + + +//! find the standard deviation of a diagview +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const diagview& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "stddev(): given object has no elements" ); + + return std::sqrt( op_var::direct_var(A, norm_type) ); + } + + + +template +inline +arma_warn_unused +typename get_pod_type::result +stddev(const subview_elem1& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const Col X(A); + + return stddev(X, norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_strans.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_strans.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,59 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_strans +//! @{ + + + +template +arma_inline +const Op +strans(const Base& X, const typename arma_cx_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Op(X.get_ref()); + } + + + +template +arma_inline +const Op +strans(const Base& X, const typename arma_not_cx::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Op(X.get_ref()); + } + + + +//! two consecutive transpose operations cancel each other +template +arma_inline +const T1& +strans(const Op& X) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("strans(): removing op_strans"); + + return X.m; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_sum.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_sum.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,152 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_sum +//! @{ + + +//! \brief +//! Delayed sum of elements of a matrix along a specified dimension (either rows or columns). +//! The result is stored in a dense matrix that has either one column or one row. +//! For dim = 0, find the sum of each column. +//! For dim = 1, find the sum of each row. +//! The default is dim = 0. +//! NOTE: this function works differently than in Matlab/Octave. + +template +arma_inline +const Op +sum(const Base& X, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), dim, 0); + } + + +//! \brief +//! Immediate 'sum all values' operation for a row vector +template +inline +arma_warn_unused +eT +sum(const Row& X) + { + arma_extra_debug_sigprint(); + + return accu(X); + } + + + +//! \brief +//! Immediate 'sum all values' operation for a column vector +template +inline +arma_warn_unused +eT +sum(const Col& X) + { + arma_extra_debug_sigprint(); + + return accu(X); + } + + + +//! \brief +//! Immediate 'sum all values' operation, +//! invoked, for example, by: sum(sum(A)) + +template +inline +arma_warn_unused +typename T1::elem_type +sum(const Op& in) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("sum(): two consecutive sum() calls detected"); + + return accu(in.m); + } + + + +template +arma_inline +const Op, op_sum> +sum(const Op& in, const uword dim) + { + arma_extra_debug_sigprint(); + + return Op, op_sum>(in, dim, 0); + } + + + +//! sum all values of a subview_row +template +inline +arma_warn_unused +eT +sum(const subview_row& X) + { + arma_extra_debug_sigprint(); + + return accu(X); + } + + + +//! sum all values of a subview_col +template +inline +arma_warn_unused +eT +sum(const subview_col& X) + { + arma_extra_debug_sigprint(); + + return accu(X); + } + + + +//! sum all values of a diagview +template +inline +arma_warn_unused +eT +sum(const diagview& X) + { + arma_extra_debug_sigprint(); + + return accu(X); + } + + + +template +inline +arma_warn_unused +eT +sum(const subview_elem1& A) + { + arma_extra_debug_sigprint(); + + return accu(A); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_svd.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_svd.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,181 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_svd +//! @{ + + + +template +inline +bool +svd + ( + Col& S, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + // it doesn't matter if X is an alias of S, as auxlib::svd() makes a copy of X + + const bool status = auxlib::svd(S, X); + + if(status == false) + { + S.reset(); + arma_bad("svd(): failed to converge", false); + } + + return status; + } + + + +template +inline +Col +svd + ( + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + Col out; + + const bool status = auxlib::svd(out, X); + + if(status == false) + { + out.reset(); + arma_bad("svd(): failed to converge"); + } + + return out; + } + + + +template +inline +bool +svd + ( + Mat& U, + Col& S, + Mat& V, + const Base& X, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + arma_debug_check + ( + ( ((void*)(&U) == (void*)(&S)) || (&U == &V) || ((void*)(&S) == (void*)(&V)) ), + "svd(): two or more output objects are the same object" + ); + + // auxlib::svd() makes an internal copy of X + const bool status = auxlib::svd(U, S, V, X); + + if(status == false) + { + U.reset(); + S.reset(); + V.reset(); + arma_bad("svd(): failed to converge", false); + } + + return status; + } + + + +template +inline +bool +svd_econ + ( + Mat& U, + Col& S, + Mat& V, + const Base& X, + const char mode = 'b', + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + arma_debug_check + ( + ( ((void*)(&U) == (void*)(&S)) || (&U == &V) || ((void*)(&S) == (void*)(&V)) ), + "svd_econ(): two or more output objects are the same object" + ); + + arma_debug_check + ( + ( (mode != 'l') && (mode != 'r') && (mode != 'b') ), + "svd_econ(): parameter 'mode' is incorrect" + ); + + + // auxlib::svd_econ() makes an internal copy of X + const bool status = auxlib::svd_econ(U, S, V, X, mode); + + if(status == false) + { + U.reset(); + S.reset(); + V.reset(); + arma_bad("svd_econ(): failed to converge", false); + } + + return status; + } + + + +template +arma_deprecated +inline +bool +svd_thin + ( + Mat& U, + Col& S, + Mat& V, + const Base& X, + const char mode = 'b', + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_ignore(junk); + + return svd_econ(U,S,V,X,mode); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_syl_lyap.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_syl_lyap.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,96 @@ +// Copyright (C) 2011-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2011-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_syl_lyap +//! @{ + + +//! find the solution of the Sylvester equation AX + XB = C +template +inline +bool +syl + ( + Mat & out, + const Base& in_A, + const Base& in_B, + const Base& in_C, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp_A(in_A.get_ref(), out); + const unwrap_check tmp_B(in_B.get_ref(), out); + const unwrap_check tmp_C(in_C.get_ref(), out); + + const Mat& A = tmp_A.M; + const Mat& B = tmp_B.M; + const Mat& C = tmp_C.M; + + const bool status = auxlib::syl(out, A, B, C); + + if(status == false) + { + out.reset(); + arma_bad("syl(): equation appears to be singular", false); + } + + return status; + } + + + +template +inline +Mat +syl + ( + const Base& in_A, + const Base& in_B, + const Base& in_C, + const typename arma_blas_type_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + const unwrap tmp_A( in_A.get_ref() ); + const unwrap tmp_B( in_B.get_ref() ); + const unwrap tmp_C( in_C.get_ref() ); + + const Mat& A = tmp_A.M; + const Mat& B = tmp_B.M; + const Mat& C = tmp_C.M; + + Mat out; + + const bool status = auxlib::syl(out, A, B, C); + + if(status == false) + { + out.reset(); + arma_bad("syl(): equation appears to be singular"); + } + + return out; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_symmat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_symmat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,42 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_symmat +//! @{ + + +template +arma_inline +const Op +symmatu(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), 0, 0); + } + + + +template +arma_inline +const Op +symmatl(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), 1, 0); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_toeplitz.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_toeplitz.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,57 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2011 Alcatel Lucent +// Copyright (C) 2011 Gerhard Schreiber +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_toeplitz +//! @{ + + + +template +inline +Glue +toeplitz(const Base& X) + { + arma_extra_debug_sigprint(); + + return Glue( X.get_ref(), X.get_ref() ); + } + + + +template +inline +Glue +toeplitz(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return Glue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +Glue +circ_toeplitz(const Base& X) + { + arma_extra_debug_sigprint(); + + return Glue( X.get_ref(), X.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_trace.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_trace.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,114 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_trace +//! @{ + + +//! Immediate trace (sum of diagonal elements) of a square dense matrix +template +inline +arma_warn_unused +typename T1::elem_type +trace(const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const Proxy A(X.get_ref()); + + arma_debug_check( (A.get_n_rows() != A.get_n_cols()), "trace(): matrix must be square sized" ); + + const uword N = A.get_n_rows(); + eT val = eT(0); + + for(uword i=0; i +inline +arma_warn_unused +typename T1::elem_type +trace(const Op& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const diagmat_proxy A(X.m); + + const uword N = A.n_elem; + + eT val = eT(0); + + for(uword i=0; i +inline +arma_warn_unused +typename T1::elem_type +trace(const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(X.A); + const unwrap tmp2(X.B); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + arma_debug_assert_mul_size(A, B, "matrix multiply"); + + arma_debug_check( (A.n_rows != B.n_cols), "trace(): matrix must be square sized" ); + + const uword N1 = A.n_rows; + const uword N2 = A.n_cols; + eT val = eT(0); + + for(uword i=0; i +arma_inline +const Op +trans(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +//! two consecutive transpose operations cancel each other +template +arma_inline +const T1& +trans(const Op& X) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("trans(): removing op_htrans"); + + return X.m; + } + + + +template +arma_inline +const Op +htrans(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref()); + } + + + +//! two consecutive hermitian transpose operations cancel each other +template +arma_inline +const T1& +htrans(const Op& X) + { + arma_extra_debug_sigprint(); + arma_extra_debug_print("htrans(): removing op_htrans"); + + return X.m; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_trig.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_trig.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,348 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_trig +//! @{ + +// +// trigonometric functions: +// cos family: cos, acos, cosh, acosh +// sin family: sin, asin, sinh, asinh +// tan family: tan, atan, tanh, atanh + + +// +// cos + +template +arma_inline +const eOp +cos(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +cos(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// acos + +template +arma_inline +const eOp +acos(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +acos(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// cosh + +template +arma_inline +const eOp +cosh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +cosh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// acosh + +template +arma_inline +const eOp +acosh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +acosh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// sin + +template +arma_inline +const eOp +sin(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +sin(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// asin + +template +arma_inline +const eOp +asin(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +asin(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// sinh + +template +arma_inline +const eOp +sinh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +sinh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// asinh + +template +arma_inline +const eOp +asinh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +asinh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// tan + +template +arma_inline +const eOp +tan(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +tan(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// atan + +template +arma_inline +const eOp +atan(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +atan(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// tanh + +template +arma_inline +const eOp +tanh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +tanh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +// +// atanh + +template +arma_inline +const eOp +atanh(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +atanh(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_trimat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_trimat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,42 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_trimat +//! @{ + + +template +arma_inline +const Op +trimatu(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), 0, 0); + } + + + +template +arma_inline +const Op +trimatl(const Base& X) + { + arma_extra_debug_sigprint(); + + return Op(X.get_ref(), 1, 0); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_trunc_exp.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_trunc_exp.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,84 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup fn_trunc_exp +//! @{ + + + +template +inline +static +typename arma_float_only::result +trunc_exp(const eT x) + { + if(std::numeric_limits::is_iec559 && (x >= Math::log_max() )) + { + return std::numeric_limits::max(); + } + else + { + return std::exp(x); + } + } + + + +template +inline +static +typename arma_integral_only::result +trunc_exp(const eT x) + { + return eT( trunc_exp( double(x) ) ); + } + + + +template +arma_inline +static +std::complex +trunc_exp(const std::complex& x) + { + return std::exp(x); + } + + + +template +arma_inline +const eOp +trunc_exp(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +trunc_exp(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_trunc_log.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_trunc_log.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,90 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_trunc_log +//! @{ + + + +template +inline +static +typename arma_float_only::result +trunc_log(const eT x) + { + if(std::numeric_limits::is_iec559) + { + if(x == std::numeric_limits::infinity()) + { + return Math::log_max(); + } + else + { + return (x <= eT(0)) ? Math::log_min() : std::log(x); + } + } + else + { + return std::log(x); + } + } + + + +template +inline +static +typename arma_integral_only::result +trunc_log(const eT x) + { + return eT( trunc_log( double(x) ) ); + } + + + +template +inline +static +std::complex +trunc_log(const std::complex& x) + { + return std::log(x); + } + + + +template +arma_inline +const eOp +trunc_log(const Base& A) + { + arma_extra_debug_sigprint(); + + return eOp(A.get_ref()); + } + + + +template +arma_inline +const eOpCube +trunc_log(const BaseCube& A) + { + arma_extra_debug_sigprint(); + + return eOpCube(A.get_ref()); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_var.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_var.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,127 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_var +//! @{ + + + +template +inline +const mtOp +var(const Base& X, const uword norm_type = 0, const uword dim = 0) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), norm_type, dim); + } + + + +//! Immediate 'find the variance of a row vector' operation +template +inline +arma_warn_unused +typename get_pod_type::result +var(const Row& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "var(): given object has no elements" ); + + return op_var::direct_var(A.mem, A_n_elem, norm_type); + } + + + +//! Immediate 'find the variance of a column vector' operation +template +inline +arma_warn_unused +typename get_pod_type::result +var(const Col& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const uword A_n_elem = A.n_elem; + + arma_debug_check( (A_n_elem == 0), "var(): given object has no elements" ); + + return op_var::direct_var(A.mem, A_n_elem, norm_type); + } + + + +template +inline +arma_warn_unused +typename get_pod_type::result +var(const subview_row& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "var(): given object has no elements" ); + + return op_var::direct_var(A, norm_type); + } + + + +template +inline +arma_warn_unused +typename get_pod_type::result +var(const subview_col& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "var(): given object has no elements" ); + + return op_var::direct_var(A.colptr(0), A.n_rows, norm_type); + } + + + +template +inline +arma_warn_unused +typename get_pod_type::result +var(const diagview& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (A.n_elem == 0), "var(): given object has no elements" ); + + return op_var::direct_var(A, norm_type); + } + + + +template +inline +arma_warn_unused +typename get_pod_type::result +var(const subview_elem1& A, const uword norm_type = 0) + { + arma_extra_debug_sigprint(); + + const Col X(A); + + return var(X, norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/fn_zeros.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/fn_zeros.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,100 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup fn_zeros +//! @{ + + +//! Generate a vector with all elements set to zero +arma_inline +const Gen +zeros(const uword n_elem) + { + arma_extra_debug_sigprint(); + + return Gen(n_elem, 1); + } + + + +template +arma_inline +const Gen +zeros(const uword n_elem, const arma_empty_class junk1 = arma_empty_class(), const typename arma_Mat_Col_Row_only::result* junk2 = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + if(is_Row::value == true) + { + return Gen(1, n_elem); + } + else + { + return Gen(n_elem, 1); + } + } + + + +//! Generate a dense matrix with all elements set to zero +arma_inline +const Gen +zeros(const uword n_rows, const uword n_cols) + { + arma_extra_debug_sigprint(); + + return Gen(n_rows, n_cols); + } + + + +template +arma_inline +const Gen +zeros(const uword n_rows, const uword n_cols, const typename arma_Mat_Col_Row_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return Gen(n_rows, n_cols); + } + + + +arma_inline +const GenCube +zeros(const uword n_rows, const uword n_cols, const uword n_slices) + { + arma_extra_debug_sigprint(); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +template +arma_inline +const GenCube +zeros(const uword n_rows, const uword n_cols, const uword n_slices, const typename arma_Cube_only::result* junk = 0) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + return GenCube(n_rows, n_cols, n_slices); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/format_wrap.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/format_wrap.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,551 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup format_wrap +//! @{ + + +//! \namespace arma_boost namespace for functions and classes which partially emulate Boost functionality +namespace arma_boost + { + + #if defined(ARMA_USE_BOOST_FORMAT) + + using boost::format; + using boost::basic_format; + using boost::str; + + #else + + #if defined(ARMA_HAVE_STD_SNPRINTF) + + #define arma_snprintf std::snprintf + + #else + + // better-than-nothing emulation of C99 snprintf(), + // with correct return value and null-terminated output string. + // note that _snprintf() provided by MS is not a good substitute for snprintf() + + inline + int + arma_snprintf(char* out, size_t size, const char* fmt, ...) + { + size_t i; + + for(i=0; i 0) + out[size-1] = char(0); + + return int(i); + } + + #endif + + class format + { + public: + + format(const char* in_fmt) + : A(in_fmt) + { + } + + format(const std::string& in_fmt) + : A(in_fmt) + { + } + + + const std::string A; + + private: + format(); + }; + + + + template + class basic_format + { + public: + + basic_format(const T1& in_A, const T2& in_B) + : A(in_A) + , B(in_B) + { + } + + const T1& A; + const T2& B; + + private: + basic_format(); + }; + + + + template + inline + basic_format< format, T2 > + operator% (const format& X, const T2& arg) + { + return basic_format< format, T2 >(X, arg); + } + + + + template + inline + basic_format< basic_format, T3 > + operator% (const basic_format& X, const T3& arg) + { + return basic_format< basic_format, T3 >(X, arg); + } + + + + template + inline + std::string + str(const basic_format< format, T2>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.c_str(), X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + inline + std::string + str(const basic_format< basic_format< format, T2>, T3>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.A.c_str(), X.A.B, X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + inline + std::string + str(const basic_format< basic_format< basic_format< format, T2>, T3>, T4>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.A.A.c_str(), X.A.A.B, X.A.B, X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + inline + std::string + str(const basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.A.A.A.c_str(), X.A.A.A.B, X.A.A.B, X.A.B, X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + inline + std::string + str(const basic_format< basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>, T6>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.A.A.A.A.c_str(), X.A.A.A.A.B, X.A.A.A.B, X.A.A.B, X.A.B, X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + inline + std::string + str(const basic_format< basic_format< basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>, T6>, T7>& X) + { + char local_buffer[1024]; + char* buffer = local_buffer; + + int buffer_size = 1024; + int required_size = buffer_size; + + bool using_local_buffer = true; + + std::string out; + + do + { + if(using_local_buffer == false) + { + buffer = new char[buffer_size]; + } + + required_size = arma_snprintf(buffer, size_t(buffer_size), X.A.A.A.A.A.A.A.c_str(), X.A.A.A.A.A.B, X.A.A.A.A.B, X.A.A.A.B, X.A.A.B, X.A.B, X.B); + + if(required_size < buffer_size) + { + if(required_size > 0) + { + out = buffer; + } + } + else + { + buffer_size *= 2; + } + + if(using_local_buffer == true) + { + using_local_buffer = false; + } + else + { + delete[] buffer; + } + + } while( (required_size >= buffer_size) ); + + return out; + } + + + + template + struct format_metaprog + { + static const uword depth = 0; + + inline + static + const std::string& + get_fmt(const T1& X) + { + return X.A; + } + }; + + + + //template<> + template + struct format_metaprog< basic_format > + { + static const uword depth = 1 + format_metaprog::depth; + + inline + static + const std::string& + get_fmt(const T1& X) + { + return format_metaprog::get_fmt(X.A); + } + + }; + + + + template + inline + std::string + str(const basic_format& X) + { + return format_metaprog< basic_format >::get_fmt(X.A); + } + + + + template + inline + std::ostream& + operator<< (std::ostream& o, const basic_format& X) + { + o << str(X); + return o; + } + + + #endif + + + template struct string_only { }; + template<> struct string_only { typedef std::string result; }; + + template struct char_only { }; + template<> struct char_only { typedef char result; }; + + template + struct basic_format_only { }; + + #if defined(ARMA_USE_BOOST_FORMAT) + template + struct basic_format_only< basic_format > { typedef basic_format result; }; + #else + template + struct basic_format_only< basic_format > { typedef basic_format result; }; + #endif + + + + template + inline + static + const T1& + str_wrapper(const T1& x, const typename string_only::result* junk = 0) + { + arma_ignore(junk); + + return x; + } + + + + template + inline + static + const T1* + str_wrapper(const T1* x, const typename char_only::result* junk = 0) + { + arma_ignore(junk); + + return x; + } + + + + template + inline + static + std::string + str_wrapper(const T1& x, const typename basic_format_only::result* junk = 0) + { + arma_ignore(junk); + + return str(x); + } + + } + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/forward_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/forward_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,148 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +using std::cout; +using std::cerr; +using std::endl; +using std::ios; + +template class Mat; +template class Col; +template class Row; +template class Cube; +template class field; + +template class subview; +template class subview_col; +template class subview_row; +template class subview_cube; +template class subview_field; + +template class diagview; + +template class subview_elem1; +template class subview_elem2; + + +class arma_empty_class {}; + +class diskio; + +class op_min; +class op_max; + +class op_strans; +class op_htrans; +class op_inv; +class op_sum; +class op_abs; +class op_diagmat; +class op_trimat; + +class eop_conj; + +class glue_times; +class glue_times_diag; + +class glue_rel_lt; +class glue_rel_gt; +class glue_rel_lteq; +class glue_rel_gteq; +class glue_rel_eq; +class glue_rel_noteq; + +class op_rel_lt_pre; +class op_rel_lt_post; +class op_rel_gt_pre; +class op_rel_gt_post; +class op_rel_lteq_pre; +class op_rel_lteq_post; +class op_rel_gteq_pre; +class op_rel_gteq_post; +class op_rel_eq; +class op_rel_noteq; + +class gen_ones_diag; +class gen_ones_full; +class gen_zeros; +class gen_randu; +class gen_randn; + + +template class gemm; +template class gemv; + + +template< typename eT, typename gen_type> class Gen; + +template< typename T1, typename op_type> class Op; +template< typename T1, typename eop_type> class eOp; +template class mtOp; + +template< typename T1, typename T2, typename glue_type> class Glue; +template< typename T1, typename T2, typename eglue_type> class eGlue; +template class mtGlue; + + + +template< typename eT, typename gen_type> class GenCube; + +template< typename T1, typename op_type> class OpCube; +template< typename T1, typename eop_type> class eOpCube; +template class mtOpCube; + +template< typename T1, typename T2, typename glue_type> class GlueCube; +template< typename T1, typename T2, typename eglue_type> class eGlueCube; +template class mtGlueCube; + + +template class Proxy; +template class ProxyCube; + + + +//! \addtogroup injector +//! @{ + + +struct injector_end_of_row {}; + +static const injector_end_of_row endr = injector_end_of_row(); +//!< endr indicates "end of row" when using the << operator; +//!< similar conceptual meaning to std::endl + +//! @} + + + +//! \addtogroup diskio +//! @{ + + +enum file_type + { + file_type_unknown, + auto_detect, //!< Automatically detect the file type (file must be one of the following types) + raw_ascii, //!< ASCII format (text), without any other information. + arma_ascii, //!< Armadillo ASCII format (text), with information about matrix type and size + csv_ascii, //!< comma separated values (CSV), without any other information + raw_binary, //!< raw binary format, without any other information. + arma_binary, //!< Armadillo binary format, with information about matrix type and size + pgm_binary, //!< Portable Grey Map (greyscale image) + ppm_binary //!< Portable Pixel Map (colour image), used by the field and cube classes + }; + + +//! @} + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/gemm.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/gemm.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,506 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup gemm +//! @{ + + + +//! for tiny square matrices, size <= 4x4 +template +class gemm_emul_tinysq + { + public: + + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const eT alpha = eT(1), + const eT beta = eT(0) + ) + { + arma_extra_debug_sigprint(); + + switch(A.n_rows) + { + case 4: + gemv_emul_tinysq::apply( C.colptr(3), A, B.colptr(3), alpha, beta ); + + case 3: + gemv_emul_tinysq::apply( C.colptr(2), A, B.colptr(2), alpha, beta ); + + case 2: + gemv_emul_tinysq::apply( C.colptr(1), A, B.colptr(1), alpha, beta ); + + case 1: + gemv_emul_tinysq::apply( C.colptr(0), A, B.colptr(0), alpha, beta ); + + default: + ; + } + } + + }; + + + +template +class gemm_emul_large + { + public: + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const eT alpha = eT(1), + const eT beta = eT(0) + ) + { + arma_extra_debug_sigprint(); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (do_trans_A == false) && (do_trans_B == false) ) + { + arma_aligned podarray tmp(A_n_cols); + eT* A_rowdata = tmp.memptr(); + + for(uword row_A=0; row_A < A_n_rows; ++row_A) + { + tmp.copy_row(A, row_A); + + for(uword col_B=0; col_B < B_n_cols; ++col_B) + { + const eT acc = op_dot::direct_dot_arma(B_n_rows, A_rowdata, B.colptr(col_B)); + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(row_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(row_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(row_A,col_B) = acc + beta*C.at(row_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(row_A,col_B) = alpha*acc + beta*C.at(row_A,col_B); + } + + } + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) ) + { + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + // col_A is interpreted as row_A when storing the results in matrix C + + const eT* A_coldata = A.colptr(col_A); + + for(uword col_B=0; col_B < B_n_cols; ++col_B) + { + const eT acc = op_dot::direct_dot_arma(B_n_rows, A_coldata, B.colptr(col_B)); + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,col_B) = acc + beta*C.at(col_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,col_B) = alpha*acc + beta*C.at(col_A,col_B); + } + + } + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) ) + { + Mat BB; + op_strans::apply_noalias(BB, B); + + gemm_emul_large::apply(C, A, BB, alpha, beta); + } + else + if( (do_trans_A == true) && (do_trans_B == true) ) + { + // mat B_tmp = trans(B); + // dgemm_arma::apply(C, A, B_tmp, alpha, beta); + + + // By using the trans(A)*trans(B) = trans(B*A) equivalency, + // transpose operations are not needed + + arma_aligned podarray tmp(B.n_cols); + eT* B_rowdata = tmp.memptr(); + + for(uword row_B=0; row_B < B_n_rows; ++row_B) + { + tmp.copy_row(B, row_B); + + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + const eT acc = op_dot::direct_dot_arma(A_n_rows, B_rowdata, A.colptr(col_A)); + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,row_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,row_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,row_B) = acc + beta*C.at(col_A,row_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,row_B) = alpha*acc + beta*C.at(col_A,row_B); + } + + } + } + + } + } + + }; + + + +template +class gemm_emul + { + public: + + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const eT alpha = eT(1), + const eT beta = eT(0), + const typename arma_not_cx::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (A_n_rows <= 4) && (A_n_rows == A_n_cols) && (A_n_rows == B_n_rows) && (B_n_rows == B_n_cols) ) + { + if(do_trans_B == false) + { + gemm_emul_tinysq::apply(C, A, B, alpha, beta); + } + else + { + Mat BB(A_n_rows, A_n_rows); + op_strans::apply_noalias_tinysq(BB, B); + + gemm_emul_tinysq::apply(C, A, BB, alpha, beta); + } + } + else + { + gemm_emul_large::apply(C, A, B, alpha, beta); + } + } + + + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const eT alpha = eT(1), + const eT beta = eT(0), + const typename arma_cx_only::result* junk = 0 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + // "better than nothing" handling of hermitian transposes for complex number matrices + + Mat tmp_A; + Mat tmp_B; + + if(do_trans_A) + { + op_htrans::apply_noalias(tmp_A, A); + } + + if(do_trans_B) + { + op_htrans::apply_noalias(tmp_B, B); + } + + const Mat& AA = (do_trans_A == false) ? A : tmp_A; + const Mat& BB = (do_trans_B == false) ? B : tmp_B; + + const uword A_n_rows = AA.n_rows; + const uword A_n_cols = AA.n_cols; + + const uword B_n_rows = BB.n_rows; + const uword B_n_cols = BB.n_cols; + + if( (A_n_rows <= 4) && (A_n_rows == A_n_cols) && (A_n_rows == B_n_rows) && (B_n_rows == B_n_cols) ) + { + gemm_emul_tinysq::apply(C, AA, BB, alpha, beta); + } + else + { + gemm_emul_large::apply(C, AA, BB, alpha, beta); + } + } + + }; + + + +//! \brief +//! Wrapper for ATLAS/BLAS dgemm function, using template arguments to control the arguments passed to dgemm. +//! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes) + +template +class gemm + { + public: + + template + inline + static + void + apply_blas_type( Mat& C, const Mat& A, const Mat& B, const eT alpha = eT(1), const eT beta = eT(0) ) + { + arma_extra_debug_sigprint(); + + if( (A.n_elem <= 48u) && (B.n_elem <= 48u) ) + { + gemm_emul::apply(C,A,B,alpha,beta); + } + else + { + #if defined(ARMA_USE_ATLAS) + { + arma_extra_debug_print("atlas::cblas_gemm()"); + + atlas::cblas_gemm + ( + atlas::CblasColMajor, + (do_trans_A) ? ( is_complex::value ? CblasConjTrans : atlas::CblasTrans ) : atlas::CblasNoTrans, + (do_trans_B) ? ( is_complex::value ? CblasConjTrans : atlas::CblasTrans ) : atlas::CblasNoTrans, + C.n_rows, + C.n_cols, + (do_trans_A) ? A.n_rows : A.n_cols, + (use_alpha) ? alpha : eT(1), + A.mem, + (do_trans_A) ? A.n_rows : C.n_rows, + B.mem, + (do_trans_B) ? C.n_cols : ( (do_trans_A) ? A.n_rows : A.n_cols ), + (use_beta) ? beta : eT(0), + C.memptr(), + C.n_rows + ); + } + #elif defined(ARMA_USE_BLAS) + { + arma_extra_debug_print("blas::gemm()"); + + const char trans_A = (do_trans_A) ? ( is_complex::value ? 'C' : 'T' ) : 'N'; + const char trans_B = (do_trans_B) ? ( is_complex::value ? 'C' : 'T' ) : 'N'; + + const blas_int m = C.n_rows; + const blas_int n = C.n_cols; + const blas_int k = (do_trans_A) ? A.n_rows : A.n_cols; + + const eT local_alpha = (use_alpha) ? alpha : eT(1); + + const blas_int lda = (do_trans_A) ? k : m; + const blas_int ldb = (do_trans_B) ? n : k; + + const eT local_beta = (use_beta) ? beta : eT(0); + + arma_extra_debug_print( arma_boost::format("blas::gemm(): trans_A = %c") % trans_A ); + arma_extra_debug_print( arma_boost::format("blas::gemm(): trans_B = %c") % trans_B ); + + blas::gemm + ( + &trans_A, + &trans_B, + &m, + &n, + &k, + &local_alpha, + A.mem, + &lda, + B.mem, + &ldb, + &local_beta, + C.memptr(), + &m + ); + } + #else + { + gemm_emul::apply(C,A,B,alpha,beta); + } + #endif + } + } + + + + //! immediate multiplication of matrices A and B, storing the result in C + template + inline + static + void + apply( Mat& C, const Mat& A, const Mat& B, const eT alpha = eT(1), const eT beta = eT(0) ) + { + gemm_emul::apply(C,A,B,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const float alpha = float(1), + const float beta = float(0) + ) + { + gemm::apply_blas_type(C,A,B,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const double alpha = double(1), + const double beta = double(0) + ) + { + gemm::apply_blas_type(C,A,B,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + Mat< std::complex >& C, + const Mat< std::complex >& A, + const Mat< std::complex >& B, + const std::complex alpha = std::complex(1), + const std::complex beta = std::complex(0) + ) + { + gemm::apply_blas_type(C,A,B,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + Mat< std::complex >& C, + const Mat< std::complex >& A, + const Mat< std::complex >& B, + const std::complex alpha = std::complex(1), + const std::complex beta = std::complex(0) + ) + { + gemm::apply_blas_type(C,A,B,alpha,beta); + } + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/gemm_mixed.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/gemm_mixed.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,453 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup gemm_mixed +//! @{ + + + +//! \brief +//! Matrix multplication where the matrices have differing element types. +//! Uses caching for speedup. +//! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes) + +template +class gemm_mixed_large + { + public: + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const out_eT alpha = out_eT(1), + const out_eT beta = out_eT(0) + ) + { + arma_extra_debug_sigprint(); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (do_trans_A == false) && (do_trans_B == false) ) + { + podarray tmp(A_n_cols); + in_eT1* A_rowdata = tmp.memptr(); + + for(uword row_A=0; row_A < A_n_rows; ++row_A) + { + tmp.copy_row(A, row_A); + + for(uword col_B=0; col_B < B_n_cols; ++col_B) + { + const in_eT2* B_coldata = B.colptr(col_B); + + out_eT acc = out_eT(0); + for(uword i=0; i < B_n_rows; ++i) + { + acc += upgrade_val::apply(A_rowdata[i]) * upgrade_val::apply(B_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(row_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(row_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(row_A,col_B) = acc + beta*C.at(row_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(row_A,col_B) = alpha*acc + beta*C.at(row_A,col_B); + } + + } + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) ) + { + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + // col_A is interpreted as row_A when storing the results in matrix C + + const in_eT1* A_coldata = A.colptr(col_A); + + for(uword col_B=0; col_B < B_n_cols; ++col_B) + { + const in_eT2* B_coldata = B.colptr(col_B); + + out_eT acc = out_eT(0); + for(uword i=0; i < B_n_rows; ++i) + { + acc += upgrade_val::apply(A_coldata[i]) * upgrade_val::apply(B_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,col_B) = acc + beta*C.at(col_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,col_B) = alpha*acc + beta*C.at(col_A,col_B); + } + + } + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) ) + { + Mat B_tmp; + + op_strans::apply_noalias(B_tmp, B); + + gemm_mixed_large::apply(C, A, B_tmp, alpha, beta); + } + else + if( (do_trans_A == true) && (do_trans_B == true) ) + { + // mat B_tmp = trans(B); + // dgemm_arma::apply(C, A, B_tmp, alpha, beta); + + + // By using the trans(A)*trans(B) = trans(B*A) equivalency, + // transpose operations are not needed + + podarray tmp(B_n_cols); + in_eT2* B_rowdata = tmp.memptr(); + + for(uword row_B=0; row_B < B_n_rows; ++row_B) + { + tmp.copy_row(B, row_B); + + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + const in_eT1* A_coldata = A.colptr(col_A); + + out_eT acc = out_eT(0); + for(uword i=0; i < A_n_rows; ++i) + { + acc += upgrade_val::apply(B_rowdata[i]) * upgrade_val::apply(A_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,row_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,row_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,row_B) = acc + beta*C.at(col_A,row_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,row_B) = alpha*acc + beta*C.at(col_A,row_B); + } + + } + } + + } + } + + }; + + + +//! Matrix multplication where the matrices have different element types. +//! Simple version (no caching). +//! Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes) +template +class gemm_mixed_small + { + public: + + template + arma_hot + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const out_eT alpha = out_eT(1), + const out_eT beta = out_eT(0) + ) + { + arma_extra_debug_sigprint(); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + if( (do_trans_A == false) && (do_trans_B == false) ) + { + for(uword row_A = 0; row_A < A_n_rows; ++row_A) + { + for(uword col_B = 0; col_B < B_n_cols; ++col_B) + { + const in_eT2* B_coldata = B.colptr(col_B); + + out_eT acc = out_eT(0); + for(uword i = 0; i < B_n_rows; ++i) + { + const out_eT val1 = upgrade_val::apply(A.at(row_A,i)); + const out_eT val2 = upgrade_val::apply(B_coldata[i]); + acc += val1 * val2; + //acc += upgrade_val::apply(A.at(row_A,i)) * upgrade_val::apply(B_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(row_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(row_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(row_A,col_B) = acc + beta*C.at(row_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(row_A,col_B) = alpha*acc + beta*C.at(row_A,col_B); + } + } + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) ) + { + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + // col_A is interpreted as row_A when storing the results in matrix C + + const in_eT1* A_coldata = A.colptr(col_A); + + for(uword col_B=0; col_B < B_n_cols; ++col_B) + { + const in_eT2* B_coldata = B.colptr(col_B); + + out_eT acc = out_eT(0); + for(uword i=0; i < B_n_rows; ++i) + { + acc += upgrade_val::apply(A_coldata[i]) * upgrade_val::apply(B_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,col_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,col_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,col_B) = acc + beta*C.at(col_A,col_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,col_B) = alpha*acc + beta*C.at(col_A,col_B); + } + + } + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) ) + { + for(uword row_A = 0; row_A < A_n_rows; ++row_A) + { + for(uword row_B = 0; row_B < B_n_rows; ++row_B) + { + out_eT acc = out_eT(0); + for(uword i = 0; i < B_n_cols; ++i) + { + acc += upgrade_val::apply(A.at(row_A,i)) * upgrade_val::apply(B.at(row_B,i)); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(row_A,row_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(row_A,row_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(row_A,row_B) = acc + beta*C.at(row_A,row_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(row_A,row_B) = alpha*acc + beta*C.at(row_A,row_B); + } + } + } + } + else + if( (do_trans_A == true) && (do_trans_B == true) ) + { + for(uword row_B=0; row_B < B_n_rows; ++row_B) + { + + for(uword col_A=0; col_A < A_n_cols; ++col_A) + { + const in_eT1* A_coldata = A.colptr(col_A); + + out_eT acc = out_eT(0); + for(uword i=0; i < A_n_rows; ++i) + { + acc += upgrade_val::apply(B.at(row_B,i)) * upgrade_val::apply(A_coldata[i]); + } + + if( (use_alpha == false) && (use_beta == false) ) + { + C.at(col_A,row_B) = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + C.at(col_A,row_B) = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + C.at(col_A,row_B) = acc + beta*C.at(col_A,row_B); + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + C.at(col_A,row_B) = alpha*acc + beta*C.at(col_A,row_B); + } + + } + } + + } + } + + }; + + + + + +//! \brief +//! Matrix multplication where the matrices have differing element types. + +template +class gemm_mixed + { + public: + + //! immediate multiplication of matrices A and B, storing the result in C + template + inline + static + void + apply + ( + Mat& C, + const Mat& A, + const Mat& B, + const out_eT alpha = out_eT(1), + const out_eT beta = out_eT(0) + ) + { + arma_extra_debug_sigprint(); + + Mat tmp_A; + Mat tmp_B; + + const bool predo_trans_A = ( (do_trans_A == true) && (is_complex::value == true) ); + const bool predo_trans_B = ( (do_trans_B == true) && (is_complex::value == true) ); + + if(do_trans_A) + { + op_htrans::apply_noalias(tmp_A, A); + } + + if(do_trans_B) + { + op_htrans::apply_noalias(tmp_B, B); + } + + const Mat& AA = (predo_trans_A == false) ? A : tmp_A; + const Mat& BB = (predo_trans_B == false) ? B : tmp_B; + + if( (AA.n_elem <= 64u) && (BB.n_elem <= 64u) ) + { + gemm_mixed_small<((predo_trans_A) ? false : do_trans_A), ((predo_trans_B) ? false : do_trans_B), use_alpha, use_beta>::apply(C, AA, BB, alpha, beta); + } + else + { + gemm_mixed_large<((predo_trans_A) ? false : do_trans_A), ((predo_trans_B) ? false : do_trans_B), use_alpha, use_beta>::apply(C, AA, BB, alpha, beta); + } + } + + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/gemv.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/gemv.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,492 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup gemv +//! @{ + + + +//! for tiny square matrices, size <= 4x4 +template +class gemv_emul_tinysq + { + public: + + + template + struct pos + { + static const uword n2 = (do_trans_A == false) ? (row + col*2) : (col + row*2); + static const uword n3 = (do_trans_A == false) ? (row + col*3) : (col + row*3); + static const uword n4 = (do_trans_A == false) ? (row + col*4) : (col + row*4); + }; + + + + template + arma_hot + arma_inline + static + void + assign(eT* y, const eT acc, const eT alpha, const eT beta) + { + if(use_beta == false) + { + y[i] = (use_alpha == false) ? acc : alpha*acc; + } + else + { + const eT tmp = y[i]; + + y[i] = beta*tmp + ( (use_alpha == false) ? acc : alpha*acc ); + } + } + + + + template + arma_hot + inline + static + void + apply( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0) ) + { + arma_extra_debug_sigprint(); + + const eT* Am = A.memptr(); + + switch(A.n_rows) + { + case 1: + { + const eT acc = Am[0] * x[0]; + + assign(y, acc, alpha, beta); + } + break; + + + case 2: + { + const eT x0 = x[0]; + const eT x1 = x[1]; + + const eT acc0 = Am[pos<0,0>::n2]*x0 + Am[pos<0,1>::n2]*x1; + const eT acc1 = Am[pos<1,0>::n2]*x0 + Am[pos<1,1>::n2]*x1; + + assign(y, acc0, alpha, beta); + assign(y, acc1, alpha, beta); + } + break; + + + case 3: + { + const eT x0 = x[0]; + const eT x1 = x[1]; + const eT x2 = x[2]; + + const eT acc0 = Am[pos<0,0>::n3]*x0 + Am[pos<0,1>::n3]*x1 + Am[pos<0,2>::n3]*x2; + const eT acc1 = Am[pos<1,0>::n3]*x0 + Am[pos<1,1>::n3]*x1 + Am[pos<1,2>::n3]*x2; + const eT acc2 = Am[pos<2,0>::n3]*x0 + Am[pos<2,1>::n3]*x1 + Am[pos<2,2>::n3]*x2; + + assign(y, acc0, alpha, beta); + assign(y, acc1, alpha, beta); + assign(y, acc2, alpha, beta); + } + break; + + + case 4: + { + const eT x0 = x[0]; + const eT x1 = x[1]; + const eT x2 = x[2]; + const eT x3 = x[3]; + + const eT acc0 = Am[pos<0,0>::n4]*x0 + Am[pos<0,1>::n4]*x1 + Am[pos<0,2>::n4]*x2 + Am[pos<0,3>::n4]*x3; + const eT acc1 = Am[pos<1,0>::n4]*x0 + Am[pos<1,1>::n4]*x1 + Am[pos<1,2>::n4]*x2 + Am[pos<1,3>::n4]*x3; + const eT acc2 = Am[pos<2,0>::n4]*x0 + Am[pos<2,1>::n4]*x1 + Am[pos<2,2>::n4]*x2 + Am[pos<2,3>::n4]*x3; + const eT acc3 = Am[pos<3,0>::n4]*x0 + Am[pos<3,1>::n4]*x1 + Am[pos<3,2>::n4]*x2 + Am[pos<3,3>::n4]*x3; + + assign(y, acc0, alpha, beta); + assign(y, acc1, alpha, beta); + assign(y, acc2, alpha, beta); + assign(y, acc3, alpha, beta); + } + break; + + + default: + ; + } + } + + }; + + + +//! \brief +//! Partial emulation of ATLAS/BLAS gemv(). +//! 'y' is assumed to have been set to the correct size (i.e. taking into account the transpose) + +template +class gemv_emul_large + { + public: + + template + arma_hot + inline + static + void + apply( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0) ) + { + arma_extra_debug_sigprint(); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + if(do_trans_A == false) + { + if(A_n_rows == 1) + { + const eT acc = op_dot::direct_dot_arma(A_n_cols, A.mem, x); + + if( (use_alpha == false) && (use_beta == false) ) + { + y[0] = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + y[0] = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + y[0] = acc + beta*y[0]; + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + y[0] = alpha*acc + beta*y[0]; + } + } + else + for(uword row=0; row < A_n_rows; ++row) + { + eT acc = eT(0); + + for(uword i=0; i < A_n_cols; ++i) + { + acc += A.at(row,i) * x[i]; + } + + if( (use_alpha == false) && (use_beta == false) ) + { + y[row] = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + y[row] = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + y[row] = acc + beta*y[row]; + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + y[row] = alpha*acc + beta*y[row]; + } + } + } + else + if(do_trans_A == true) + { + for(uword col=0; col < A_n_cols; ++col) + { + // col is interpreted as row when storing the results in 'y' + + + // const eT* A_coldata = A.colptr(col); + // + // eT acc = eT(0); + // for(uword row=0; row < A_n_rows; ++row) + // { + // acc += A_coldata[row] * x[row]; + // } + + const eT acc = op_dot::direct_dot_arma(A_n_rows, A.colptr(col), x); + + if( (use_alpha == false) && (use_beta == false) ) + { + y[col] = acc; + } + else + if( (use_alpha == true) && (use_beta == false) ) + { + y[col] = alpha * acc; + } + else + if( (use_alpha == false) && (use_beta == true) ) + { + y[col] = acc + beta*y[col]; + } + else + if( (use_alpha == true) && (use_beta == true) ) + { + y[col] = alpha*acc + beta*y[col]; + } + + } + } + } + + }; + + + +template +class gemv_emul + { + public: + + template + arma_hot + inline + static + void + apply( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0), const typename arma_not_cx::result* junk = 0 ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + if( (A_n_rows <= 4) && (A_n_rows == A_n_cols) ) + { + gemv_emul_tinysq::apply(y, A, x, alpha, beta); + } + else + { + gemv_emul_large::apply(y, A, x, alpha, beta); + } + } + + + + template + arma_hot + inline + static + void + apply( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0), const typename arma_cx_only::result* junk = 0 ) + { + arma_extra_debug_sigprint(); + + Mat tmp_A; + + if(do_trans_A) + { + op_htrans::apply_noalias(tmp_A, A); + } + + const Mat& AA = (do_trans_A == false) ? A : tmp_A; + + const uword AA_n_rows = AA.n_rows; + const uword AA_n_cols = AA.n_cols; + + if( (AA_n_rows <= 4) && (AA_n_rows == AA_n_cols) ) + { + gemv_emul_tinysq::apply(y, AA, x, alpha, beta); + } + else + { + gemv_emul_large::apply(y, AA, x, alpha, beta); + } + } + }; + + + +//! \brief +//! Wrapper for ATLAS/BLAS gemv function, using template arguments to control the arguments passed to gemv. +//! 'y' is assumed to have been set to the correct size (i.e. taking into account the transpose) + +template +class gemv + { + public: + + template + inline + static + void + apply_blas_type( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0) ) + { + arma_extra_debug_sigprint(); + + if(A.n_elem <= 64u) + { + gemv_emul::apply(y,A,x,alpha,beta); + } + else + { + #if defined(ARMA_USE_ATLAS) + { + arma_extra_debug_print("atlas::cblas_gemv()"); + + atlas::cblas_gemv + ( + atlas::CblasColMajor, + (do_trans_A) ? ( is_complex::value ? CblasConjTrans : atlas::CblasTrans ) : atlas::CblasNoTrans, + A.n_rows, + A.n_cols, + (use_alpha) ? alpha : eT(1), + A.mem, + A.n_rows, + x, + 1, + (use_beta) ? beta : eT(0), + y, + 1 + ); + } + #elif defined(ARMA_USE_BLAS) + { + arma_extra_debug_print("blas::gemv()"); + + const char trans_A = (do_trans_A) ? ( is_complex::value ? 'C' : 'T' ) : 'N'; + const blas_int m = A.n_rows; + const blas_int n = A.n_cols; + const eT local_alpha = (use_alpha) ? alpha : eT(1); + //const blas_int lda = A.n_rows; + const blas_int inc = 1; + const eT local_beta = (use_beta) ? beta : eT(0); + + arma_extra_debug_print( arma_boost::format("blas::gemv(): trans_A = %c") % trans_A ); + + blas::gemv + ( + &trans_A, + &m, + &n, + &local_alpha, + A.mem, + &m, // lda + x, + &inc, + &local_beta, + y, + &inc + ); + } + #else + { + gemv_emul::apply(y,A,x,alpha,beta); + } + #endif + } + + } + + + + template + arma_inline + static + void + apply( eT* y, const Mat& A, const eT* x, const eT alpha = eT(1), const eT beta = eT(0) ) + { + gemv_emul::apply(y,A,x,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + float* y, + const Mat& A, + const float* x, + const float alpha = float(1), + const float beta = float(0) + ) + { + gemv::apply_blas_type(y,A,x,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + double* y, + const Mat& A, + const double* x, + const double alpha = double(1), + const double beta = double(0) + ) + { + gemv::apply_blas_type(y,A,x,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + std::complex* y, + const Mat< std::complex >& A, + const std::complex* x, + const std::complex alpha = std::complex(1), + const std::complex beta = std::complex(0) + ) + { + gemv::apply_blas_type(y,A,x,alpha,beta); + } + + + + arma_inline + static + void + apply + ( + std::complex* y, + const Mat< std::complex >& A, + const std::complex* x, + const std::complex alpha = std::complex(1), + const std::complex beta = std::complex(0) + ) + { + gemv::apply_blas_type(y,A,x,alpha,beta); + } + + + + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_conv_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_conv_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,30 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_conv +//! @{ + + + +class glue_conv + { + public: + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_conv_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_conv_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,111 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_conv +//! @{ + + +//! rudimentary implementation of the convolution operation + +template +inline +void +glue_conv::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check A_tmp(X.A, out); + const unwrap_check B_tmp(X.B, out); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + arma_debug_check( ( (A.is_vec() == false) || (B.is_vec() == false) ), "conv(): inputs must be vectors" ); + + + const Mat& h = (A.n_elem <= B.n_elem) ? A : B; + const Mat& x = (A.n_elem <= B.n_elem) ? B : A; + + + const uword h_n_elem = h.n_elem; + const uword x_n_elem = x.n_elem; + const uword out_n_elem = h_n_elem + x_n_elem - 1; + + + if( (h_n_elem == 0) || (x_n_elem == 0) ) + { + out.reset(); + return; + } + + + (A.n_cols == 1) ? out.set_size(out_n_elem, 1) : out.set_size(1, out_n_elem); + + + const eT* h_mem = h.memptr(); + const eT* x_mem = x.memptr(); + eT* out_mem = out.memptr(); + + + for(uword out_i = 0; out_i < (h_n_elem-1); ++out_i) + { + eT acc = eT(0); + + uword h_i = out_i; + + for(uword x_i = 0; x_i <= out_i; ++x_i, --h_i) + { + acc += h_mem[h_i] * x_mem[x_i]; + } + + out_mem[out_i] = acc; + } + + + for(uword out_i = h_n_elem-1; out_i < out_n_elem - (h_n_elem-1); ++out_i) + { + eT acc = eT(0); + + uword h_i = h_n_elem - 1; + + for(uword x_i = out_i - h_n_elem + 1; x_i <= out_i; ++x_i, --h_i) + { + acc += h_mem[h_i] * x_mem[x_i]; + } + + out_mem[out_i] = acc; + } + + + for(uword out_i = out_n_elem - (h_n_elem-1); out_i < out_n_elem; ++out_i) + { + eT acc = eT(0); + + uword h_i = h_n_elem - 1; + + for(uword x_i = out_i - h_n_elem + 1; x_i < x_n_elem; ++x_i, --h_i) + { + acc += h_mem[h_i] * x_mem[x_i]; + } + + out_mem[out_i] = acc; + } + + + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cor_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cor_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,34 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_cor +//! @{ + + + +class glue_cor + { + public: + + template inline static void direct_cor(Mat& out, const Mat& A, const Mat& B, const uword norm_type); + template inline static void direct_cor(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat< std::complex >& B, const uword norm_type); + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cor_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cor_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,181 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_cor +//! @{ + + + +template +inline +void +glue_cor::direct_cor(Mat& out, const Mat& A, const Mat& B, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(A.is_empty() || B.is_empty() ) + { + out.reset(); + return; + } + + if(A.is_vec() && B.is_vec()) + { + arma_debug_check( (A.n_elem != B.n_elem), "cor(): the number of elements in the two vectors must match" ); + + const eT* A_ptr = A.memptr(); + const eT* B_ptr = B.memptr(); + + eT A_acc = eT(0); + eT B_acc = eT(0); + eT out_acc = eT(0); + + const uword N = A.n_elem; + + for(uword i=0; i 1) ? eT(N-1) : eT(1) ) : eT(N); + + out.set_size(1,1); + out[0] = out_acc/norm_val; + + const Mat stddev_A = (A.n_rows == 1) ? Mat(stddev(trans(A))) : Mat(stddev(A)); + const Mat stddev_B = (B.n_rows == 1) ? Mat(stddev(trans(B))) : Mat(stddev(B)); + + out /= stddev_A * stddev_B; + } + else + { + arma_debug_assert_same_size(A, B, "cor()"); + + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + out = trans(A) * B; + out -= (trans(sum(A)) * sum(B))/eT(N); + out /= norm_val; + out /= trans(stddev(A)) * stddev(B); + } + } + + + +template +inline +void +glue_cor::direct_cor(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat< std::complex >& B, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(A.is_empty() || B.is_empty() ) + { + out.reset(); + return; + } + + if(A.is_vec() && B.is_vec()) + { + arma_debug_check( (A.n_elem != B.n_elem), "cor(): the number of elements in the two vectors must match" ); + + const eT* A_ptr = A.memptr(); + const eT* B_ptr = B.memptr(); + + eT A_acc = eT(0); + eT B_acc = eT(0); + eT out_acc = eT(0); + + const uword N = A.n_elem; + + for(uword i=0; i 1) ? eT(N-1) : eT(1) ) : eT(N); + + out.set_size(1,1); + out[0] = out_acc/norm_val; + + const Mat stddev_A = (A.n_rows == 1) ? Mat(stddev(trans(A))) : Mat(stddev(A)); + const Mat stddev_B = (B.n_rows == 1) ? Mat(stddev(trans(B))) : Mat(stddev(B)); + + out /= conv_to< Mat >::from( stddev_A * stddev_B ); + } + else + { + arma_debug_assert_same_size(A, B, "cor()"); + + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + out = trans(A) * B; // out = strans(conj(A)) * B; + out -= (trans(sum(A)) * sum(B))/eT(N); // out -= (strans(conj(sum(A))) * sum(B))/eT(N); + out /= norm_val; + out /= conv_to< Mat >::from( trans(stddev(A)) * stddev(B) ); + } + } + + + +template +inline +void +glue_cor::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check A_tmp(X.A, out); + const unwrap_check B_tmp(X.B, out); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + const uword norm_type = X.aux_uword; + + if(&A != &B) + { + glue_cor::direct_cor(out, A, B, norm_type); + } + else + { + op_cor::direct_cor(out, A, norm_type); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cov_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cov_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,34 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_cov +//! @{ + + + +class glue_cov + { + public: + + template inline static void direct_cov(Mat& out, const Mat& A, const Mat& B, const uword norm_type); + template inline static void direct_cov(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat< std::complex >& B, const uword norm_type); + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cov_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cov_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,158 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_cov +//! @{ + + + +template +inline +void +glue_cov::direct_cov(Mat& out, const Mat& A, const Mat& B, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(A.is_vec() && B.is_vec()) + { + arma_debug_check( (A.n_elem != B.n_elem), "cov(): the number of elements in A and B must match" ); + + const eT* A_ptr = A.memptr(); + const eT* B_ptr = B.memptr(); + + eT A_acc = eT(0); + eT B_acc = eT(0); + eT out_acc = eT(0); + + const uword N = A.n_elem; + + for(uword i=0; i 1) ? eT(N-1) : eT(1) ) : eT(N); + + out.set_size(1,1); + out[0] = out_acc/norm_val; + } + else + { + arma_debug_assert_same_size(A, B, "cov()"); + + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + out = trans(A) * B; + out -= (trans(sum(A)) * sum(B))/eT(N); + out /= norm_val; + } + } + + + +template +inline +void +glue_cov::direct_cov(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat< std::complex >& B, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(A.is_vec() && B.is_vec()) + { + arma_debug_check( (A.n_elem != B.n_elem), "cov(): the number of elements in A and B must match" ); + + const eT* A_ptr = A.memptr(); + const eT* B_ptr = B.memptr(); + + eT A_acc = eT(0); + eT B_acc = eT(0); + eT out_acc = eT(0); + + const uword N = A.n_elem; + + for(uword i=0; i 1) ? eT(N-1) : eT(1) ) : eT(N); + + out.set_size(1,1); + out[0] = out_acc/norm_val; + } + else + { + arma_debug_assert_same_size(A, B, "cov()"); + + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + out = trans(A) * B; // out = strans(conj(A)) * B; + out -= (trans(sum(A)) * sum(B))/eT(N); // out -= (strans(conj(sum(A))) * sum(B))/eT(N); + out /= norm_val; + } + } + + + +template +inline +void +glue_cov::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check A_tmp(X.A, out); + const unwrap_check B_tmp(X.B, out); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + const uword norm_type = X.aux_uword; + + if(&A != &B) + { + glue_cov::direct_cov(out, A, B, norm_type); + } + else + { + op_cov::direct_cov(out, A, norm_type); + } + + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cross_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cross_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,30 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_cross +//! @{ + + + +class glue_cross + { + public: + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_cross_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_cross_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,57 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_cross +//! @{ + + + +template +inline +void +glue_cross::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_check( ((A.get_n_elem() != 3) || (B.get_n_elem() != 3)), "cross(): input vectors must have 3 elements" ); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + eT* out_mem = out.memptr(); + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + + const eT ax = PA[0]; + const eT ay = PA[1]; + const eT az = PA[2]; + + const eT bx = PB[0]; + const eT by = PB[1]; + const eT bz = PB[2]; + + out_mem[0] = ay*bz - az*by; + out_mem[1] = az*bx - ax*bz; + out_mem[2] = ax*by - ay*bx; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_join_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_join_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,34 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_join +//! @{ + + + +class glue_join + { + public: + + template + inline static void apply(Mat& out, const Glue& X); + + template + inline static void apply(Cube& out, const GlueCube& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_join_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_join_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,195 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_join +//! @{ + + + +template +inline +void +glue_join::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap A_tmp(X.A); + const unwrap B_tmp(X.B); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + const uword join_type = X.aux_uword; + + if(join_type == 0) + { + arma_debug_check + ( + ( (A_n_cols != B_n_cols) && ( (A_n_rows > 0) || (A_n_cols > 0) ) && ( (B_n_rows > 0) || (B_n_cols > 0) ) ), + "join_cols(): number of columns must be the same" + ); + } + else + { + arma_debug_check + ( + ( (A_n_rows != B.n_rows) && ( (A_n_rows > 0) || (A_n_cols > 0) ) && ( (B_n_rows > 0) || (B_n_cols > 0) ) ), + "join_rows(): number of rows must be the same" + ); + } + + + if( (&out != &A) && (&out != &B) ) + { + if(join_type == 0) // join columns (i.e. result matrix has more rows) + { + out.set_size( A_n_rows + B_n_rows, (std::max)(A_n_cols, B_n_cols) ); + + if( out.n_elem > 0 ) + { + if(A.is_empty() == false) + { + out.submat(0, 0, A_n_rows-1, out.n_cols-1) = A; + } + + if(B.is_empty() == false) + { + out.submat(A_n_rows, 0, out.n_rows-1, out.n_cols-1) = B; + } + } + } + else // join rows (i.e. result matrix has more columns) + { + out.set_size( (std::max)(A_n_rows, B_n_rows), A_n_cols + B_n_cols ); + + if( out.n_elem > 0 ) + { + if(A.is_empty() == false) + { + out.submat(0, 0, out.n_rows-1, A.n_cols-1) = A; + } + + if(B.is_empty() == false) + { + out.submat(0, A_n_cols, out.n_rows-1, out.n_cols-1) = B; + } + } + } + } + else // we have aliasing + { + Mat C; + + if(join_type == 0) + { + C.set_size( A_n_rows + B_n_rows, (std::max)(A_n_cols, B_n_cols) ); + + if( C.n_elem > 0 ) + { + if(A.is_empty() == false) + { + C.submat(0, 0, A_n_rows-1, C.n_cols-1) = A; + } + + if(B.is_empty() == false) + { + C.submat(A_n_rows, 0, C.n_rows-1, C.n_cols-1) = B; + } + } + } + else + { + C.set_size( (std::max)(A_n_rows, B_n_rows), A_n_cols + B_n_cols ); + + if( C.n_elem > 0 ) + { + if(A.is_empty() == false) + { + C.submat(0, 0, C.n_rows-1, A_n_cols-1) = A; + } + + if(B.is_empty() == false) + { + C.submat(0, A_n_cols, C.n_rows-1, C.n_cols-1) = B; + } + } + } + + out.steal_mem(C); + } + + } + + + +template +inline +void +glue_join::apply(Cube& out, const GlueCube& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_cube A_tmp(X.A); + const unwrap_cube B_tmp(X.B); + + const Cube& A = A_tmp.M; + const Cube& B = B_tmp.M; + + if(A.n_elem == 0) + { + out = B; + return; + } + + if(B.n_elem == 0) + { + out = A; + return; + } + + + arma_debug_check( ( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) ), "join_slices(): size of slices must be the same" ); + + + if( (&out != &A) && (&out != &B) ) + { + out.set_size(A.n_rows, A.n_cols, A.n_slices + B.n_slices); + + out.slices(0, A.n_slices-1 ) = A; + out.slices(A.n_slices, out.n_slices-1) = B; + } + else // we have aliasing + { + Cube C(A.n_rows, A.n_cols, A.n_slices + B.n_slices); + + C.slices(0, A.n_slices-1) = A; + C.slices(A.n_slices, C.n_slices-1) = B; + + out.steal_mem(C); + } + + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_kron_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_kron_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,35 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_kron +//! @{ + + + +class glue_kron + { + public: + + template inline static void direct_kron(Mat& out, const Mat& A, const Mat& B); + template inline static void direct_kron(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat& B); + template inline static void direct_kron(Mat< std::complex >& out, const Mat& A, const Mat< std::complex >& B); + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_kron_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_kron_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,129 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_kron +//! @{ + + + +//! \brief +//! both input matrices have the same element type +template +inline +void +glue_kron::direct_kron(Mat& out, const Mat& A, const Mat& B) + { + arma_extra_debug_sigprint(); + + const uword A_rows = A.n_rows; + const uword A_cols = A.n_cols; + const uword B_rows = B.n_rows; + const uword B_cols = B.n_cols; + + out.set_size(A_rows*B_rows, A_cols*B_cols); + + for(uword i = 0; i < A_rows; i++) + { + for(uword j = 0; j < A_cols; j++) + { + out.submat(i*B_rows, j*B_cols, (i+1)*B_rows-1, (j+1)*B_cols-1) = A(i,j) * B; + } + } + } + + + +//! \brief +//! different types of input matrices +//! A -> complex, B -> basic element type +template +inline +void +glue_kron::direct_kron(Mat< std::complex >& out, const Mat< std::complex >& A, const Mat& B) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + const uword A_rows = A.n_rows; + const uword A_cols = A.n_cols; + const uword B_rows = B.n_rows; + const uword B_cols = B.n_cols; + + out.set_size(A_rows*B_rows, A_cols*B_cols); + + Mat tmp_B = conv_to< Mat >::from(B); + + for(uword i = 0; i < A_rows; i++) + { + for(uword j = 0; j < A_cols; j++) + { + out.submat(i*B_rows, j*B_cols, (i+1)*B_rows-1, (j+1)*B_cols-1) = A(i,j) * tmp_B; + } + } + } + + + +//! \brief +//! different types of input matrices +//! A -> basic element type, B -> complex +template +inline +void +glue_kron::direct_kron(Mat< std::complex >& out, const Mat& A, const Mat< std::complex >& B) + { + arma_extra_debug_sigprint(); + + const uword A_rows = A.n_rows; + const uword A_cols = A.n_cols; + const uword B_rows = B.n_rows; + const uword B_cols = B.n_cols; + + out.set_size(A_rows*B_rows, A_cols*B_cols); + + for(uword i = 0; i < A_rows; i++) + { + for(uword j = 0; j < A_cols; j++) + { + out.submat(i*B_rows, j*B_cols, (i+1)*B_rows-1, (j+1)*B_cols-1) = A(i,j) * B; + } + } + } + + + +//! \brief +//! apply Kronecker product for two objects with same element type +template +inline +void +glue_kron::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check A_tmp(X.A, out); + const unwrap_check B_tmp(X.B, out); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + glue_kron::direct_kron(out, A, B); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_mixed_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_mixed_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,81 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_mixed +//! @{ + + + +class glue_mixed_times + { + public: + + template + inline static void apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_times>& X); + }; + + + +class glue_mixed_plus + { + public: + + template + inline static void apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_plus>& X); + + template + inline static void apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_plus>& X); + }; + + + +class glue_mixed_minus + { + public: + + template + inline static void apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_minus>& X); + + template + inline static void apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_minus>& X); + }; + + + +class glue_mixed_div + { + public: + + template + inline static void apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_div>& X); + + template + inline static void apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_div>& X); + }; + + + +class glue_mixed_schur + { + public: + + template + inline static void apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_schur>& X); + + template + inline static void apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_schur>& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_mixed_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_mixed_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,336 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_mixed +//! @{ + + + +//! matrix multiplication with different element types +template +inline +void +glue_mixed_times::apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_times>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + // TODO: extend the unwrap_check framework to handle mixed matrix types + + const unwrap tmp1(X.A); + const unwrap tmp2(X.B); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + const bool A_is_alias = ( ((void *)&out) == ((void *)&A) ); + const bool B_is_alias = ( ((void *)&out) == ((void *)&B) ); + + const Mat* AA_ptr = A_is_alias ? new Mat(A) : 0; + const Mat* BB_ptr = B_is_alias ? new Mat(B) : 0; + + const Mat& AA = A_is_alias ? *AA_ptr : A; + const Mat& BB = B_is_alias ? *BB_ptr : B; + + arma_debug_assert_mul_size(AA, BB, "multiplication"); + + out.set_size(AA.n_rows, BB.n_cols); + + gemm_mixed<>::apply(out, AA, BB); + + if(A_is_alias == true) + { + delete AA_ptr; + } + + if(B_is_alias == true) + { + delete BB_ptr; + } + } + + + +//! matrix addition with different element types +template +inline +void +glue_mixed_plus::apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_plus>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "addition"); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) + upgrade_val::apply(B[i]); + } + } + + + +//! matrix subtraction with different element types +template +inline +void +glue_mixed_minus::apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_minus>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "subtraction"); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) - upgrade_val::apply(B[i]); + } + } + + + +//! element-wise matrix division with different element types +template +inline +void +glue_mixed_div::apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_div>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "element-wise division"); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) / upgrade_val::apply(B[i]); + } + } + + + +//! element-wise matrix multiplication with different element types +template +inline +void +glue_mixed_schur::apply(Mat::eT>& out, const mtGlue::eT, T1, T2, glue_mixed_schur>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "element-wise multiplication"); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) * upgrade_val::apply(B[i]); + } + } + + + +// +// +// + + + +//! cube addition with different element types +template +inline +void +glue_mixed_plus::apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_plus>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const ProxyCube A(X.A); + const ProxyCube B(X.B); + + arma_debug_assert_same_size(A, B, "addition"); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) + upgrade_val::apply(B[i]); + } + } + + + +//! cube subtraction with different element types +template +inline +void +glue_mixed_minus::apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_minus>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const ProxyCube A(X.A); + const ProxyCube B(X.B); + + arma_debug_assert_same_size(A, B, "subtraction"); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) - upgrade_val::apply(B[i]); + } + } + + + +//! element-wise cube division with different element types +template +inline +void +glue_mixed_div::apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_div>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const ProxyCube A(X.A); + const ProxyCube B(X.B); + + arma_debug_assert_same_size(A, B, "element-wise division"); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) / upgrade_val::apply(B[i]); + } + } + + + +//! element-wise cube multiplication with different element types +template +inline +void +glue_mixed_schur::apply(Cube::eT>& out, const mtGlueCube::eT, T1, T2, glue_mixed_schur>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const ProxyCube A(X.A); + const ProxyCube B(X.B); + + arma_debug_assert_same_size(A, B, "element-wise multiplication"); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + out_eT* out_mem = out.memptr(); + const uword n_elem = out.n_elem; + + for(uword i=0; i::apply(A[i]) * upgrade_val::apply(B[i]); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_relational_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_relational_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,97 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_relational +//! @{ + + + +class glue_rel_lt + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +class glue_rel_gt + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +class glue_rel_lteq + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +class glue_rel_gteq + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +class glue_rel_eq + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +class glue_rel_noteq + { + public: + + template + inline static void apply(Mat & out, const mtGlue& X); + + template + inline static void apply(Cube & out, const mtGlueCube& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_relational_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_relational_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,342 @@ +// Copyright (C) 2009-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_relational +//! @{ + + + +#undef operator_rel +#undef operator_str + +#undef arma_applier_mat +#undef arma_applier_cube + + +#define arma_applier_mat(operator_rel, operator_str) \ + {\ + const Proxy P1(X.A);\ + const Proxy P2(X.B);\ + \ + arma_debug_assert_same_size(P1, P2, operator_str);\ + \ + const bool bad_alias = (Proxy::has_subview && P1.is_alias(out)) || (Proxy::has_subview && P2.is_alias(out));\ + \ + if(bad_alias == false)\ + {\ + \ + const uword n_rows = P1.get_n_rows();\ + const uword n_cols = P1.get_n_cols();\ + \ + out.set_size(n_rows, n_cols);\ + \ + uword* out_mem = out.memptr();\ + \ + const bool prefer_at_accessor = (Proxy::prefer_at_accessor || Proxy::prefer_at_accessor);\ + \ + if(prefer_at_accessor == false)\ + {\ + typename Proxy::ea_type A = P1.get_ea();\ + typename Proxy::ea_type B = P2.get_ea();\ + \ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp1(P1.Q);\ + const unwrap::stored_type> tmp2(P2.Q);\ + \ + out = (tmp1.M) operator_rel (tmp2.M);\ + }\ + } + + + + +#define arma_applier_cube(operator_rel, operator_str) \ + {\ + const ProxyCube P1(X.A);\ + const ProxyCube P2(X.B);\ + \ + arma_debug_assert_same_size(P1, P2, operator_str);\ + \ + const bool bad_alias = (ProxyCube::has_subview && P1.is_alias(out)) || (ProxyCube::has_subview && P2.is_alias(out));\ + \ + if(bad_alias == false)\ + {\ + \ + const uword n_rows = P1.get_n_rows();\ + const uword n_cols = P1.get_n_cols();\ + const uword n_slices = P1.get_n_slices();\ + \ + out.set_size(n_rows, n_cols, n_slices);\ + \ + uword* out_mem = out.memptr();\ + \ + const bool prefer_at_accessor = (ProxyCube::prefer_at_accessor || ProxyCube::prefer_at_accessor);\ + \ + if(prefer_at_accessor == false)\ + {\ + typename ProxyCube::ea_type A = P1.get_ea();\ + typename ProxyCube::ea_type B = P2.get_ea();\ + \ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp1(P1.Q);\ + const unwrap_cube::stored_type> tmp2(P2.Q);\ + \ + out = (tmp1.M) operator_rel (tmp2.M);\ + }\ + } + + + +template +inline +void +glue_rel_lt::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(<, "operator<"); + } + + + +template +inline +void +glue_rel_gt::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(>, "operator>"); + } + + + +template +inline +void +glue_rel_lteq::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(<=, "operator<="); + } + + + +template +inline +void +glue_rel_gteq::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(>=, "operator>="); + } + + + +template +inline +void +glue_rel_eq::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(==, "operator=="); + } + + + +template +inline +void +glue_rel_noteq::apply + ( + Mat & out, + const mtGlue& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_mat(!=, "operator!="); + } + + + +// +// +// + + + +template +inline +void +glue_rel_lt::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(<, "operator<"); + } + + + +template +inline +void +glue_rel_gt::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(>, "operator>"); + } + + + +template +inline +void +glue_rel_lteq::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(<=, "operator<="); + } + + + +template +inline +void +glue_rel_gteq::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(>=, "operator>="); + } + + + +template +inline +void +glue_rel_eq::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(==, "operator=="); + } + + + +template +inline +void +glue_rel_noteq::apply + ( + Cube & out, + const mtGlueCube& X + ) + { + arma_extra_debug_sigprint(); + + arma_applier_cube(!=, "operator!="); + } + + + +#undef arma_applier_mat +#undef arma_applier_cube + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_solve_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_solve_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_solve +//! @{ + + + +class glue_solve + { + public: + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +class glue_solve_tr + { + public: + + template inline static void apply(Mat& out, const Glue& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_solve_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_solve_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,99 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_solve +//! @{ + + + +template +inline +void +glue_solve::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + Mat A = X.A.get_ref(); + + const unwrap_check B_tmp(X.B, out); + const Mat& B = B_tmp.M; + + arma_debug_check( (A.n_rows != B.n_rows), "solve(): number of rows in A and B must be the same" ); + + bool status; + + if(A.n_rows == A.n_cols) + { + const uword mode = X.aux_uword; + + status = (mode == 0) ? auxlib::solve(out, A, B) : auxlib::solve(out, A, B, true); + } + else + if(A.n_rows > A.n_cols) + { + arma_extra_debug_print("solve(): detected over-determined system"); + status = auxlib::solve_od(out, A, B); + } + else + { + arma_extra_debug_print("solve(): detected under-determined system"); + status = auxlib::solve_ud(out, A, B); + } + + if(status == false) + { + out.reset(); + arma_bad("solve(): solution not found"); + } + } + + + +template +inline +void +glue_solve_tr::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check A_tmp(X.A, out); + const unwrap_check B_tmp(X.B, out); + + const Mat& A = A_tmp.M; + const Mat& B = B_tmp.M; + + bool err_state = false; + char* err_msg = 0; + + arma_debug_set_error( err_state, err_msg, ((&A) == (&B)), "solve(): A is an alias of B" ); + arma_debug_set_error( err_state, err_msg, (A.n_rows != B.n_rows), "solve(): number of rows in A and B must be the same" ); + arma_debug_set_error( err_state, err_msg, (A.is_square() == false), "solve(): A is not a square matrix" ); + + arma_debug_check(err_state, err_msg); + + const bool status = auxlib::solve_tr(out, A, B, X.aux_uword); + + if(status == false) + { + out.reset(); + arma_bad("solve(): solution not found"); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_times_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_times_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,111 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_times +//! @{ + + + +//! \brief +//! Template metaprogram depth_lhs +//! calculates the number of Glue instances on the left hand side argument of Glue +//! i.e. it recursively expands each Tx, until the type of Tx is not "Glue<..,.., glue_type>" (i.e the "glue_type" changes) + +template +struct depth_lhs + { + static const uword num = 0; + }; + +template +struct depth_lhs< glue_type, Glue > + { + static const uword num = 1 + depth_lhs::num; + }; + + + +template +struct glue_times_redirect + { + template + inline static void apply(Mat& out, const Glue& X); + }; + + +template<> +struct glue_times_redirect<3> + { + template + inline static void apply(Mat& out, const Glue< Glue,T3,glue_times>& X); + }; + + +template<> +struct glue_times_redirect<4> + { + template + inline static void apply(Mat& out, const Glue< Glue< Glue, T3, glue_times>, T4, glue_times>& X); + }; + + + +//! Class which implements the immediate multiplication of two or more matrices +class glue_times + { + public: + + + template + inline static void apply(Mat& out, const Glue& X); + + + template + inline static void apply_inplace(Mat& out, const T1& X); + + template + arma_hot inline static void apply_inplace_plus(Mat& out, const Glue& X, const sword sign); + + template + inline static void apply_mixed(Mat::result>& out, const Mat& X, const Mat& Y); + + + template + arma_inline static uword mul_storage_cost(const Mat& A, const Mat& B, const bool do_trans_A, const bool do_trans_B); + + template + arma_hot inline static void apply(Mat& out, const Mat& A, const Mat& B, const eT val, const bool do_trans_A, const bool do_trans_B, const bool do_scalar_times); + + template + inline static void apply(Mat& out, const Mat& A, const Mat& B, const Mat& C, const eT val, const bool do_trans_A, const bool do_trans_B, const bool do_trans_C, const bool do_scalar_times); + + template + inline static void apply(Mat& out, const Mat& A, const Mat& B, const Mat& C, const Mat& D, const eT val, const bool do_trans_A, const bool do_trans_B, const bool do_trans_C, const bool do_trans_D, const bool do_scalar_times); + + }; + + + +class glue_times_diag + { + public: + + template + arma_hot inline static void apply(Mat& out, const Glue& X); + + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_times_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_times_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,694 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup glue_times +//! @{ + + + +template +template +inline +void +glue_times_redirect::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const partial_unwrap_check tmp1(X.A, out); + const partial_unwrap_check tmp2(X.B, out); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + const bool do_trans_A = tmp1.do_trans; + const bool do_trans_B = tmp2.do_trans; + + const bool use_alpha = tmp1.do_times || tmp2.do_times; + const eT alpha = use_alpha ? (tmp1.get_val() * tmp2.get_val()) : eT(0); + + glue_times::apply(out, A, B, alpha, do_trans_A, do_trans_B, use_alpha); + } + + + +template +inline +void +glue_times_redirect<3>::apply(Mat& out, const Glue< Glue, T3, glue_times>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + // there is exactly 3 objects + // hence we can safely expand X as X.A.A, X.A.B and X.B + + const partial_unwrap_check tmp1(X.A.A, out); + const partial_unwrap_check tmp2(X.A.B, out); + const partial_unwrap_check tmp3(X.B, out); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + const Mat& C = tmp3.M; + + const bool do_trans_A = tmp1.do_trans; + const bool do_trans_B = tmp2.do_trans; + const bool do_trans_C = tmp3.do_trans; + + const bool use_alpha = tmp1.do_times || tmp2.do_times || tmp3.do_times; + const eT alpha = use_alpha ? (tmp1.get_val() * tmp2.get_val() * tmp3.get_val()) : eT(0); + + glue_times::apply(out, A, B, C, alpha, do_trans_A, do_trans_B, do_trans_C, use_alpha); + } + + + +template +inline +void +glue_times_redirect<4>::apply(Mat& out, const Glue< Glue< Glue, T3, glue_times>, T4, glue_times>& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + // there is exactly 4 objects + // hence we can safely expand X as X.A.A.A, X.A.A.B, X.A.B and X.B + + const partial_unwrap_check tmp1(X.A.A.A, out); + const partial_unwrap_check tmp2(X.A.A.B, out); + const partial_unwrap_check tmp3(X.A.B, out); + const partial_unwrap_check tmp4(X.B, out); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + const Mat& C = tmp3.M; + const Mat& D = tmp4.M; + + const bool do_trans_A = tmp1.do_trans; + const bool do_trans_B = tmp2.do_trans; + const bool do_trans_C = tmp3.do_trans; + const bool do_trans_D = tmp4.do_trans; + + const bool use_alpha = tmp1.do_times || tmp2.do_times || tmp3.do_times || tmp4.do_times; + const eT alpha = use_alpha ? (tmp1.get_val() * tmp2.get_val() * tmp3.get_val() * tmp4.get_val()) : eT(0); + + glue_times::apply(out, A, B, C, D, alpha, do_trans_A, do_trans_B, do_trans_C, do_trans_D, use_alpha); + } + + + +template +inline +void +glue_times::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const sword N_mat = 1 + depth_lhs< glue_times, Glue >::num; + + arma_extra_debug_print(arma_boost::format("N_mat = %d") % N_mat); + + glue_times_redirect::apply(out, X); + } + + + +template +inline +void +glue_times::apply_inplace(Mat& out, const T1& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(X, out); + const Mat& B = tmp.M; + + arma_debug_assert_mul_size(out, B, "matrix multiplication"); + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + + if(out_n_cols == B.n_cols) + { + // size of resulting matrix is the same as 'out' + + podarray tmp(out_n_cols); + + eT* tmp_rowdata = tmp.memptr(); + + for(uword row=0; row < out_n_rows; ++row) + { + tmp.copy_row(out, row); + + for(uword col=0; col < out_n_cols; ++col) + { + out.at(row,col) = op_dot::direct_dot( out_n_cols, tmp_rowdata, B.colptr(col) ); + } + } + + } + else + { + const Mat tmp(out); + glue_times::apply(out, tmp, B, eT(1), false, false, false); + } + + } + + + +template +arma_hot +inline +void +glue_times::apply_inplace_plus(Mat& out, const Glue& X, const sword sign) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const partial_unwrap_check tmp1(X.A, out); + const partial_unwrap_check tmp2(X.B, out); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + const eT alpha = tmp1.get_val() * tmp2.get_val() * ( (sign > sword(0)) ? eT(1) : eT(-1) ); + + const bool do_trans_A = tmp1.do_trans; + const bool do_trans_B = tmp2.do_trans; + const bool use_alpha = tmp1.do_times || tmp2.do_times || (sign < sword(0)); + + arma_debug_assert_mul_size(A, B, do_trans_A, do_trans_B, "matrix multiplication"); + + const uword result_n_rows = (do_trans_A == false) ? A.n_rows : A.n_cols; + const uword result_n_cols = (do_trans_B == false) ? B.n_cols : B.n_rows; + + arma_assert_same_size(out.n_rows, out.n_cols, result_n_rows, result_n_cols, "addition"); + + if(out.n_elem > 0) + { + if( (do_trans_A == false) && (do_trans_B == false) && (use_alpha == false) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == false) && (do_trans_B == false) && (use_alpha == true) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) && (use_alpha == false) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) && (use_alpha == true) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) && (use_alpha == false) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) && (use_alpha == true) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == true) && (do_trans_B == true) && (use_alpha == false) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + else + if( (do_trans_A == true) && (do_trans_B == true) && (use_alpha == true) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha, eT(1)); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha, eT(1)); + } + else + { + gemm::apply(out, A, B, alpha, eT(1)); + } + } + } + + + } + + + +template +arma_inline +uword +glue_times::mul_storage_cost(const Mat& A, const Mat& B, const bool do_trans_A, const bool do_trans_B) + { + const uword final_A_n_rows = (do_trans_A == false) ? A.n_rows : A.n_cols; + const uword final_B_n_cols = (do_trans_B == false) ? B.n_cols : B.n_rows; + + return final_A_n_rows * final_B_n_cols; + } + + + +template +arma_hot +inline +void +glue_times::apply + ( + Mat& out, + const Mat& A, + const Mat& B, + const eT alpha, + const bool do_trans_A, + const bool do_trans_B, + const bool use_alpha + ) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_mul_size(A, B, do_trans_A, do_trans_B, "matrix multiplication"); + + const uword final_n_rows = (do_trans_A == false) ? A.n_rows : A.n_cols; + const uword final_n_cols = (do_trans_B == false) ? B.n_cols : B.n_rows; + + out.set_size(final_n_rows, final_n_cols); + + if( (A.n_elem > 0) && (B.n_elem > 0) ) + { + if( (do_trans_A == false) && (do_trans_B == false) && (use_alpha == false) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr()); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr()); + } + else + { + gemm::apply(out, A, B); + } + } + else + if( (do_trans_A == false) && (do_trans_B == false) && (use_alpha == true) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha); + } + else + { + gemm::apply(out, A, B, alpha); + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) && (use_alpha == false) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr()); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr()); + } + else + { + gemm::apply(out, A, B); + } + } + else + if( (do_trans_A == true) && (do_trans_B == false) && (use_alpha == true) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha); + } + else + if(B.n_cols == 1) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha); + } + else + { + gemm::apply(out, A, B, alpha); + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) && (use_alpha == false) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr()); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr()); + } + else + { + gemm::apply(out, A, B); + } + } + else + if( (do_trans_A == false) && (do_trans_B == true) && (use_alpha == true) ) + { + if( (A.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha); + } + else + { + gemm::apply(out, A, B, alpha); + } + } + else + if( (do_trans_A == true) && (do_trans_B == true) && (use_alpha == false) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr()); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr()); + } + else + { + gemm::apply(out, A, B); + } + } + else + if( (do_trans_A == true) && (do_trans_B == true) && (use_alpha == true) ) + { + if( (A.n_cols == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), B, A.memptr(), alpha); + } + else + if( (B.n_rows == 1) && (is_complex::value == false) ) + { + gemv::apply(out.memptr(), A, B.memptr(), alpha); + } + else + { + gemm::apply(out, A, B, alpha); + } + } + } + else + { + out.zeros(); + } + } + + + +template +inline +void +glue_times::apply + ( + Mat& out, + const Mat& A, + const Mat& B, + const Mat& C, + const eT alpha, + const bool do_trans_A, + const bool do_trans_B, + const bool do_trans_C, + const bool use_alpha + ) + { + arma_extra_debug_sigprint(); + + Mat tmp; + + if( glue_times::mul_storage_cost(A, B, do_trans_A, do_trans_B) <= glue_times::mul_storage_cost(B, C, do_trans_B, do_trans_C) ) + { + // out = (A*B)*C + glue_times::apply(tmp, A, B, alpha, do_trans_A, do_trans_B, use_alpha); + glue_times::apply(out, tmp, C, eT(0), false, do_trans_C, false ); + } + else + { + // out = A*(B*C) + glue_times::apply(tmp, B, C, alpha, do_trans_B, do_trans_C, use_alpha); + glue_times::apply(out, A, tmp, eT(0), do_trans_A, false, false ); + } + } + + + +template +inline +void +glue_times::apply + ( + Mat& out, + const Mat& A, + const Mat& B, + const Mat& C, + const Mat& D, + const eT alpha, + const bool do_trans_A, + const bool do_trans_B, + const bool do_trans_C, + const bool do_trans_D, + const bool use_alpha + ) + { + arma_extra_debug_sigprint(); + + Mat tmp; + + if( glue_times::mul_storage_cost(A, C, do_trans_A, do_trans_C) <= glue_times::mul_storage_cost(B, D, do_trans_B, do_trans_D) ) + { + // out = (A*B*C)*D + glue_times::apply(tmp, A, B, C, alpha, do_trans_A, do_trans_B, do_trans_C, use_alpha); + + glue_times::apply(out, tmp, D, eT(0), false, do_trans_D, false); + } + else + { + // out = A*(B*C*D) + glue_times::apply(tmp, B, C, D, alpha, do_trans_B, do_trans_C, do_trans_D, use_alpha); + + glue_times::apply(out, A, tmp, eT(0), do_trans_A, false, false); + } + } + + + +// +// glue_times_diag + + +template +arma_hot +inline +void +glue_times_diag::apply(Mat& out, const Glue& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const strip_diagmat S1(X.A); + const strip_diagmat S2(X.B); + + typedef typename strip_diagmat::stored_type T1_stripped; + typedef typename strip_diagmat::stored_type T2_stripped; + + if( (S1.do_diagmat == true) && (S2.do_diagmat == false) ) + { + const diagmat_proxy_check A(S1.M, out); + + const unwrap_check tmp(X.B, out); + const Mat& B = tmp.M; + + arma_debug_assert_mul_size(A.n_elem, A.n_elem, B.n_rows, B.n_cols, "matrix multiplication"); + + out.set_size(A.n_elem, B.n_cols); + + for(uword col=0; col tmp(X.A, out); + const Mat& A = tmp.M; + + const diagmat_proxy_check B(S2.M, out); + + arma_debug_assert_mul_size(A.n_rows, A.n_cols, B.n_elem, B.n_elem, "matrix multiplication"); + + out.set_size(A.n_rows, B.n_elem); + + for(uword col=0; col A(S1.M, out); + const diagmat_proxy_check B(S2.M, out); + + arma_debug_assert_mul_size(A.n_elem, A.n_elem, B.n_elem, B.n_elem, "matrix multiplication"); + + out.zeros(A.n_elem, A.n_elem); + + for(uword i=0; i inline static void apply(Mat& out, const Glue& in); + }; + + + +class glue_toeplitz_circ + { + public: + + template inline static void apply(Mat& out, const Glue& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/glue_toeplitz_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/glue_toeplitz_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,192 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2011 Alcatel Lucent +// Copyright (C) 2011 Gerhard Schreiber +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup glue_toeplitz +//! @{ + + + +template +inline +void +glue_toeplitz::apply(Mat& out, const Glue& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + if( ((void*)(&in.A)) == ((void*)(&in.B)) ) + { + arma_extra_debug_print("glue_toeplitz::apply(): one argument version"); + + const unwrap_check tmp(in.A, out); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_vec() == false), "toeplitz(): input argument must be a vector" ); + + const uword N = A.n_elem; + const eT* A_mem = A.memptr(); + + out.set_size(N,N); + + for(uword col=0; col tmp1(in.A, out); + const unwrap_check tmp2(in.B, out); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + arma_debug_check( ( (A.is_vec() == false) || (B.is_vec() == false) ), "toeplitz(): input arguments must be vectors" ); + + const uword A_N = A.n_elem; + const uword B_N = B.n_elem; + + const eT* A_mem = A.memptr(); + const eT* B_mem = B.memptr(); + + out.set_size(A_N, B_N); + + if( out.is_empty() ) + { + return; + } + + for(uword col=0; col +inline +void +glue_toeplitz_circ::apply(Mat& out, const Glue& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + if( ((void*)(&in.A)) == ((void*)(&in.B)) ) + { + arma_extra_debug_print("glue_toeplitz_circ::apply(): one argument version"); + + const unwrap_check tmp(in.A, out); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_vec() == false), "toeplitz(): input argument must be a vector" ); + + const uword N = A.n_elem; + const eT* A_mem = A.memptr(); + + out.set_size(N,N); + + + if(A.is_colvec()) + { + // A is interpreted as colvec + + for(uword col=0; col + #include + } + #else + #define ARMA_STR1(x) x + #define ARMA_STR2(x) ARMA_STR1(x) + + #define ARMA_CBLAS ARMA_STR2(ARMA_ATLAS_INCLUDE_DIR)ARMA_STR2(cblas.h) + #define ARMA_CLAPACK ARMA_STR2(ARMA_ATLAS_INCLUDE_DIR)ARMA_STR2(clapack.h) + + extern "C" + { + #include ARMA_INCFILE_WRAP(ARMA_CBLAS) + #include ARMA_INCFILE_WRAP(ARMA_CLAPACK) + } + + #undef ARMA_STR1 + #undef ARMA_STR2 + #undef ARMA_CBLAS + #undef ARMA_CLAPACK + #endif +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/injector_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/injector_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,114 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup injector +//! @{ + + + +template +class mat_injector_row + { + public: + + inline mat_injector_row(); + + inline void insert(const eT val) const; + + mutable uword n_cols; + mutable podarray A; + mutable podarray B; + }; + + + +template +class mat_injector + { + public: + + typedef typename T1::elem_type elem_type; + + inline void insert(const elem_type val) const; + inline void end_of_row() const; + inline ~mat_injector(); + + + private: + + inline mat_injector(T1& in_X, const elem_type val); + inline mat_injector(T1& in_X, const injector_end_of_row& x); + + T1& X; + mutable uword n_rows; + + mutable podarray< mat_injector_row* >* AA; + mutable podarray< mat_injector_row* >* BB; + + friend class Mat; + friend class Row; + friend class Col; + }; + + + +// + + + +template +class field_injector_row + { + public: + + inline field_injector_row(); + inline ~field_injector_row(); + + inline void insert(const oT& val) const; + + mutable uword n_cols; + mutable field* AA; + mutable field* BB; + }; + + + +template +class field_injector + { + public: + + typedef typename T1::object_type object_type; + + inline void insert(const object_type& val) const; + inline void end_of_row() const; + inline ~field_injector(); + + + private: + + inline field_injector(T1& in_X, const object_type& val); + inline field_injector(T1& in_X, const injector_end_of_row& x); + + T1& X; + mutable uword n_rows; + + mutable podarray< field_injector_row* >* AA; + mutable podarray< field_injector_row* >* BB; + + friend class field; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/injector_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/injector_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,589 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup injector +//! @{ + + + +template +inline +mat_injector_row::mat_injector_row() + : n_cols(0) + { + arma_extra_debug_sigprint(); + + A.set_size( podarray_prealloc_n_elem::val ); + } + + + +template +inline +void +mat_injector_row::insert(const eT val) const + { + arma_extra_debug_sigprint(); + + if(n_cols < A.n_elem) + { + A[n_cols] = val; + ++n_cols; + } + else + { + B.set_size(2 * A.n_elem); + + arrayops::copy(B.memptr(), A.memptr(), n_cols); + + B[n_cols] = val; + ++n_cols; + + std::swap( access::rw(A.mem), access::rw(B.mem) ); + std::swap( access::rw(A.n_elem), access::rw(B.n_elem) ); + } + } + + + +// +// +// + + + +template +inline +mat_injector::mat_injector(T1& in_X, const typename mat_injector::elem_type val) + : X(in_X) + , n_rows(1) + { + arma_extra_debug_sigprint(); + + typedef typename mat_injector::elem_type eT; + + AA = new podarray< mat_injector_row* >; + BB = new podarray< mat_injector_row* >; + + podarray< mat_injector_row* >& A = *AA; + + A.set_size(n_rows); + + for(uword row=0; row; + } + + (*(A[0])).insert(val); + } + + + +template +inline +mat_injector::mat_injector(T1& in_X, const injector_end_of_row& x) + : X(in_X) + , n_rows(1) + { + arma_extra_debug_sigprint(); + arma_ignore(x); + + typedef typename mat_injector::elem_type eT; + + AA = new podarray< mat_injector_row* >; + BB = new podarray< mat_injector_row* >; + + podarray< mat_injector_row* >& A = *AA; + + A.set_size(n_rows); + + for(uword row=0; row; + } + + (*this).end_of_row(); + } + + + +template +inline +mat_injector::~mat_injector() + { + arma_extra_debug_sigprint(); + + typedef typename mat_injector::elem_type eT; + + podarray< mat_injector_row* >& A = *AA; + + if(n_rows > 0) + { + uword max_n_cols = (*(A[0])).n_cols; + + for(uword row=1; row::value == true) + { + X.set_size(max_n_rows, max_n_cols); + + for(uword row=0; row::value == true) + { + arma_debug_check( (max_n_rows > 1), "matrix initialisation: incompatible dimensions" ); + + const uword n_cols = (*(A[0])).n_cols; + + X.set_size(1, n_cols); + + arrayops::copy( X.memptr(), (*(A[0])).A.memptr(), n_cols ); + } + else + if(is_Col::value == true) + { + const bool is_vec = ( (max_n_rows == 1) || (max_n_cols == 1) ); + + arma_debug_check( (is_vec == false), "matrix initialisation: incompatible dimensions" ); + + const uword n_elem = (std::max)(max_n_rows, max_n_cols); + + X.set_size(n_elem, 1); + + uword i = 0; + for(uword row=0; row +inline +void +mat_injector::insert(const typename mat_injector::elem_type val) const + { + arma_extra_debug_sigprint(); + + typedef typename mat_injector::elem_type eT; + + podarray< mat_injector_row* >& A = *AA; + + (*(A[n_rows-1])).insert(val); + } + + + + +template +inline +void +mat_injector::end_of_row() const + { + arma_extra_debug_sigprint(); + + typedef typename mat_injector::elem_type eT; + + podarray< mat_injector_row* >& A = *AA; + podarray< mat_injector_row* >& B = *BB; + + B.set_size( n_rows+1 ); + + arrayops::copy(B.memptr(), A.memptr(), n_rows); + + for(uword row=n_rows; row<(n_rows+1); ++row) + { + B[row] = new mat_injector_row; + } + + std::swap(AA, BB); + + n_rows += 1; + } + + + +template +arma_inline +const mat_injector& +operator<<(const mat_injector& ref, const typename mat_injector::elem_type val) + { + arma_extra_debug_sigprint(); + + ref.insert(val); + + return ref; + } + + + +template +arma_inline +const mat_injector& +operator<<(const mat_injector& ref, const injector_end_of_row& x) + { + arma_extra_debug_sigprint(); + arma_ignore(x); + + ref.end_of_row(); + + return ref; + } + + + +//// using a mixture of operator << and , doesn't work yet +//// e.g. A << 1, 2, 3 << endr +//// in the above "3 << endr" requires special handling. +//// similarly, special handling is necessary for "endr << 3" +//// +// template +// arma_inline +// const mat_injector& +// operator,(const mat_injector& ref, const typename mat_injector::elem_type val) +// { +// arma_extra_debug_sigprint(); +// +// ref.insert(val); +// +// return ref; +// } + + + +// template +// arma_inline +// const mat_injector& +// operator,(const mat_injector& ref, const injector_end_of_row& x) +// { +// arma_extra_debug_sigprint(); +// arma_ignore(x); +// +// ref.end_of_row(); +// +// return ref; +// } + + + + +// +// +// + + + +template +inline +field_injector_row::field_injector_row() + : n_cols(0) + { + arma_extra_debug_sigprint(); + + AA = new field; + BB = new field; + + field& A = *AA; + + A.set_size( field_prealloc_n_elem::val ); + } + + + +template +inline +field_injector_row::~field_injector_row() + { + arma_extra_debug_sigprint(); + + delete AA; + delete BB; + } + + + +template +inline +void +field_injector_row::insert(const oT& val) const + { + arma_extra_debug_sigprint(); + + field& A = *AA; + field& B = *BB; + + if(n_cols < A.n_elem) + { + A[n_cols] = val; + ++n_cols; + } + else + { + B.set_size(2 * A.n_elem); + + for(uword i=0; i +inline +field_injector::field_injector(T1& in_X, const typename field_injector::object_type& val) + : X(in_X) + , n_rows(1) + { + arma_extra_debug_sigprint(); + + typedef typename field_injector::object_type oT; + + AA = new podarray< field_injector_row* >; + BB = new podarray< field_injector_row* >; + + podarray< field_injector_row* >& A = *AA; + + A.set_size(n_rows); + + for(uword row=0; row; + } + + (*(A[0])).insert(val); + } + + + +template +inline +field_injector::field_injector(T1& in_X, const injector_end_of_row& x) + : X(in_X) + , n_rows(1) + { + arma_extra_debug_sigprint(); + arma_ignore(x); + + typedef typename field_injector::object_type oT; + + AA = new podarray< field_injector_row* >; + BB = new podarray< field_injector_row* >; + + podarray< field_injector_row* >& A = *AA; + + A.set_size(n_rows); + + for(uword row=0; row; + } + + (*this).end_of_row(); + } + + + +template +inline +field_injector::~field_injector() + { + arma_extra_debug_sigprint(); + + typedef typename field_injector::object_type oT; + + podarray< field_injector_row* >& A = *AA; + + if(n_rows > 0) + { + uword max_n_cols = (*(A[0])).n_cols; + + for(uword row=1; row& tmp = *((*(A[row])).AA); + X.at(row,col) = tmp[col]; + } + + for(uword col=n_cols; col +inline +void +field_injector::insert(const typename field_injector::object_type& val) const + { + arma_extra_debug_sigprint(); + + typedef typename field_injector::object_type oT; + + podarray< field_injector_row* >& A = *AA; + + (*(A[n_rows-1])).insert(val); + } + + + + +template +inline +void +field_injector::end_of_row() const + { + arma_extra_debug_sigprint(); + + typedef typename field_injector::object_type oT; + + podarray< field_injector_row* >& A = *AA; + podarray< field_injector_row* >& B = *BB; + + B.set_size( n_rows+1 ); + + for(uword row=0; row; + } + + std::swap(AA, BB); + + n_rows += 1; + } + + + +template +arma_inline +const field_injector& +operator<<(const field_injector& ref, const typename field_injector::object_type& val) + { + arma_extra_debug_sigprint(); + + ref.insert(val); + + return ref; + } + + + +template +arma_inline +const field_injector& +operator<<(const field_injector& ref, const injector_end_of_row& x) + { + arma_extra_debug_sigprint(); + arma_ignore(x); + + ref.end_of_row(); + + return ref; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/itpp_wrap.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/itpp_wrap.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,84 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup itpp_wrap +//! @{ + + +#ifdef ARMA_USE_ITPP + + #include + #include + +#else + + namespace itpp + { + + //! dummy itpp::Mat class, to prevent compilation errors + template + class Mat + { + public: + + ~Mat() {} + Mat() {} + Mat(int n_rows, int n_cols) {} + Mat(const Mat& m) {} + + const Mat& operator=(const Mat& m) { return *this; } + + int rows() const { return 0; } + int cols() const { return 0; } + int size() const { return 0; } + const eT* _data() const { return 0; } + eT* _data() { return 0; } + }; + + + //! dummy itpp::Vec class, to prevent compilation errors + template + class Vec + { + public: + + ~Vec() {} + Vec() {} + Vec(int length) {} + Vec(const Vec& m) {} + + const Vec& operator=(const Vec& m) { return *this; } + + int size() const { return 0; } + int length() const { return 0; } + const eT* _data() const { return 0; } + eT* _data() { return 0; } + }; + + typedef Mat smat; + typedef Vec svec; + + typedef Mat imat; + typedef Vec ivec; + + typedef Mat mat; + typedef Vec vec; + + typedef Mat< std::complex > cmat; + typedef Vec< std::complex > cvec; + } + +#endif + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/lapack_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/lapack_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,324 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009 Edmund Highcock +// Copyright (C) 2011 James Sanders +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#ifdef ARMA_USE_LAPACK + + +#if !defined(ARMA_BLAS_CAPITALS) + + #define arma_sgetrf sgetrf + #define arma_dgetrf dgetrf + #define arma_cgetrf cgetrf + #define arma_zgetrf zgetrf + + #define arma_sgetri sgetri + #define arma_dgetri dgetri + #define arma_cgetri cgetri + #define arma_zgetri zgetri + + #define arma_strtri strtri + #define arma_dtrtri dtrtri + #define arma_ctrtri ctrtri + #define arma_ztrtri ztrtri + + #define arma_ssyev ssyev + #define arma_dsyev dsyev + + #define arma_cheev cheev + #define arma_zheev zheev + + #define arma_sgeev sgeev + #define arma_dgeev dgeev + + #define arma_cgeev cgeev + #define arma_zgeev zgeev + + #define arma_spotrf spotrf + #define arma_dpotrf dpotrf + #define arma_cpotrf cpotrf + #define arma_zpotrf zpotrf + + #define arma_spotri spotri + #define arma_dpotri dpotri + #define arma_cpotri cpotri + #define arma_zpotri zpotri + + #define arma_sgeqrf sgeqrf + #define arma_dgeqrf dgeqrf + #define arma_cgeqrf cgeqrf + #define arma_zgeqrf zgeqrf + + #define arma_sorgqr sorgqr + #define arma_dorgqr dorgqr + + #define arma_cungqr cungqr + #define arma_zungqr zungqr + + #define arma_sgesvd sgesvd + #define arma_dgesvd dgesvd + + #define arma_cgesvd cgesvd + #define arma_zgesvd zgesvd + + #define arma_sgesv sgesv + #define arma_dgesv dgesv + #define arma_cgesv cgesv + #define arma_zgesv zgesv + + #define arma_sgels sgels + #define arma_dgels dgels + #define arma_cgels cgels + #define arma_zgels zgels + + #define arma_strtrs strtrs + #define arma_dtrtrs dtrtrs + #define arma_ctrtrs ctrtrs + #define arma_ztrtrs ztrtrs + + #define arma_sgees sgees + #define arma_dgees dgees + #define arma_cgees cgees + #define arma_zgees zgees + + #define arma_strsyl strsyl + #define arma_dtrsyl dtrsyl + #define arma_ctrsyl ctrsyl + #define arma_ztrsyl ztrsyl + + #define arma_ssytrf ssytrf + #define arma_dsytrf dsytrf + #define arma_csytrf csytrf + #define arma_zsytrf zsytrf + + #define arma_ssytri ssytri + #define arma_dsytri dsytri + #define arma_csytri csytri + #define arma_zsytri zsytri + +#else + + #define arma_sgetrf SGETRF + #define arma_dgetrf DGETRF + #define arma_cgetrf CGETRF + #define arma_zgetrf ZGETRF + + #define arma_sgetri SGETRI + #define arma_dgetri DGETRI + #define arma_cgetri CGETRI + #define arma_zgetri ZGETRI + + #define arma_strtri STRTRI + #define arma_dtrtri DTRTRI + #define arma_ctrtri CTRTRI + #define arma_ztrtri ZTRTRI + + #define arma_ssyev SSYEV + #define arma_dsyev DSYEV + + #define arma_cheev CHEEV + #define arma_zheev ZHEEV + + #define arma_sgeev SGEEV + #define arma_dgeev DGEEV + + #define arma_cgeev CGEEV + #define arma_zgeev ZGEEV + + #define arma_spotrf SPOTRF + #define arma_dpotrf DPOTRF + #define arma_cpotrf CPOTRF + #define arma_zpotrf ZPOTRF + + #define arma_spotri SPOTRI + #define arma_dpotri DPOTRI + #define arma_cpotri CPOTRI + #define arma_zpotri ZPOTRI + + #define arma_sgeqrf SGEQRF + #define arma_dgeqrf DGEQRF + #define arma_cgeqrf CGEQRF + #define arma_zgeqrf ZGEQRF + + #define arma_sorgqr SORGQR + #define arma_dorgqr DORGQR + + #define arma_cungqr CUNGQR + #define arma_zungqr ZUNGQR + + #define arma_sgesvd SGESVD + #define arma_dgesvd DGESVD + + #define arma_cgesvd CGESVD + #define arma_zgesvd ZGESVD + + #define arma_sgesv SGESV + #define arma_dgesv DGESV + #define arma_cgesv CGESV + #define arma_zgesv ZGESV + + #define arma_sgels SGELS + #define arma_dgels DGELS + #define arma_cgels CGELS + #define arma_zgels ZGELS + + #define arma_strtrs STRTRS + #define arma_dtrtrs DTRTRS + #define arma_ctrtrs CTRTRS + #define arma_ztrtrs ZTRTRS + + #define arma_sgees SGEES + #define arma_dgees DGEES + #define arma_cgees CGEES + #define arma_zgees ZGEES + + #define arma_strsyl STRSYL + #define arma_dtrsyl DTRSYL + #define arma_ctrsyl CTRSYL + #define arma_ztrsyl ZTRSYL + + #define arma_ssytrf SSYTRF + #define arma_dsytrf DSYTRF + #define arma_csytrf CSYTRF + #define arma_zsytrf ZSYTRF + + #define arma_ssytri SSYTRI + #define arma_dsytri DSYTRI + #define arma_csytri CSYTRI + #define arma_zsytri ZSYTRI + +#endif + + + +extern "C" + { + // LU factorisation + void arma_fortran(arma_sgetrf)(blas_int* m, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, blas_int* info); + void arma_fortran(arma_dgetrf)(blas_int* m, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, blas_int* info); + void arma_fortran(arma_cgetrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, blas_int* info); + void arma_fortran(arma_zgetrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, blas_int* info); + + // matrix inversion (using LU factorisation result) + void arma_fortran(arma_sgetri)(blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgetri)(blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_cgetri)(blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_zgetri)(blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info); + + // matrix inversion (triangular matrices) + void arma_fortran(arma_strtri)(char* uplo, char* diag, blas_int* n, float* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_dtrtri)(char* uplo, char* diag, blas_int* n, double* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_ctrtri)(char* uplo, char* diag, blas_int* n, void* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_ztrtri)(char* uplo, char* diag, blas_int* n, void* a, blas_int* lda, blas_int* info); + + // eigenvector decomposition of symmetric real matrices + void arma_fortran(arma_ssyev)(char* jobz, char* uplo, blas_int* n, float* a, blas_int* lda, float* w, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dsyev)(char* jobz, char* uplo, blas_int* n, double* a, blas_int* lda, double* w, double* work, blas_int* lwork, blas_int* info); + + // eigenvector decomposition of hermitian matrices (complex) + void arma_fortran(arma_cheev)(char* jobz, char* uplo, blas_int* n, void* a, blas_int* lda, float* w, void* work, blas_int* lwork, float* rwork, blas_int* info); + void arma_fortran(arma_zheev)(char* jobz, char* uplo, blas_int* n, void* a, blas_int* lda, double* w, void* work, blas_int* lwork, double* rwork, blas_int* info); + + // eigenvector decomposition of general real matrices + void arma_fortran(arma_sgeev)(char* jobvl, char* jobvr, blas_int* n, float* a, blas_int* lda, float* wr, float* wi, float* vl, blas_int* ldvl, float* vr, blas_int* ldvr, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgeev)(char* jobvl, char* jobvr, blas_int* n, double* a, blas_int* lda, double* wr, double* wi, double* vl, blas_int* ldvl, double* vr, blas_int* ldvr, double* work, blas_int* lwork, blas_int* info); + + // eigenvector decomposition of general complex matrices + void arma_fortran(arma_cgeev)(char* jobvl, char* jobvr, blas_int* n, void* a, blas_int* lda, void* w, void* vl, blas_int* ldvl, void* vr, blas_int* ldvr, void* work, blas_int* lwork, float* rwork, blas_int* info); + void arma_fortran(arma_zgeev)(char* jobvl, char* jobvr, blas_int* n, void* a, blas_int* lda, void* w, void* vl, blas_int* ldvl, void* vr, blas_int* ldvr, void* work, blas_int* lwork, double* rwork, blas_int* info); + + // Cholesky decomposition + void arma_fortran(arma_spotrf)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_dpotrf)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_cpotrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_zpotrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info); + + // matrix inversion (using Cholesky decomposition result) + void arma_fortran(arma_spotri)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_dpotri)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_cpotri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info); + void arma_fortran(arma_zpotri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info); + + // QR decomposition + void arma_fortran(arma_sgeqrf)(blas_int* m, blas_int* n, float* a, blas_int* lda, float* tau, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgeqrf)(blas_int* m, blas_int* n, double* a, blas_int* lda, double* tau, double* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_cgeqrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_zgeqrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info); + + // Q matrix calculation from QR decomposition (real matrices) + void arma_fortran(arma_sorgqr)(blas_int* m, blas_int* n, blas_int* k, float* a, blas_int* lda, float* tau, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dorgqr)(blas_int* m, blas_int* n, blas_int* k, double* a, blas_int* lda, double* tau, double* work, blas_int* lwork, blas_int* info); + + // Q matrix calculation from QR decomposition (complex matrices) + void arma_fortran(arma_cungqr)(blas_int* m, blas_int* n, blas_int* k, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_zungqr)(blas_int* m, blas_int* n, blas_int* k, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info); + + // SVD (real matrices) + void arma_fortran(arma_sgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, float* a, blas_int* lda, float* s, float* u, blas_int* ldu, float* vt, blas_int* ldvt, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, double* a, blas_int* lda, double* s, double* u, blas_int* ldu, double* vt, blas_int* ldvt, double* work, blas_int* lwork, blas_int* info); + + // SVD (complex matrices) + void arma_fortran(arma_cgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, void* a, blas_int* lda, float* s, void* u, blas_int* ldu, void* vt, blas_int* ldvt, void* work, blas_int* lwork, float* rwork, blas_int* info); + void arma_fortran(arma_zgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, void* a, blas_int* lda, double* s, void* u, blas_int* ldu, void* vt, blas_int* ldvt, void* work, blas_int* lwork, double* rwork, blas_int* info); + + // solve system of linear equations, using LU decomposition + void arma_fortran(arma_sgesv)(blas_int* n, blas_int* nrhs, float* a, blas_int* lda, blas_int* ipiv, float* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_dgesv)(blas_int* n, blas_int* nrhs, double* a, blas_int* lda, blas_int* ipiv, double* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_cgesv)(blas_int* n, blas_int* nrhs, void* a, blas_int* lda, blas_int* ipiv, void* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_zgesv)(blas_int* n, blas_int* nrhs, void* a, blas_int* lda, blas_int* ipiv, void* b, blas_int* ldb, blas_int* info); + + // solve over/underdetermined system of linear equations + void arma_fortran(arma_sgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, float* a, blas_int* lda, float* b, blas_int* ldb, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, double* a, blas_int* lda, double* b, blas_int* ldb, double* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_cgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, void* a, blas_int* lda, void* b, blas_int* ldb, void* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_zgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, void* a, blas_int* lda, void* b, blas_int* ldb, void* work, blas_int* lwork, blas_int* info); + + // solve a triangular system of linear equations + void arma_fortran(arma_strtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const float* a, blas_int* lda, float* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_dtrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const double* a, blas_int* lda, double* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_ctrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const void* a, blas_int* lda, void* b, blas_int* ldb, blas_int* info); + void arma_fortran(arma_ztrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const void* a, blas_int* lda, void* b, blas_int* ldb, blas_int* info); + + // Schur decomposition (real matrices) + void arma_fortran(arma_sgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, float* a, blas_int* lda, blas_int* sdim, float* wr, float* wi, float* vs, blas_int* ldvs, float* work, blas_int* lwork, blas_int* bwork, blas_int* info); + void arma_fortran(arma_dgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, double* a, blas_int* lda, blas_int* sdim, double* wr, double* wi, double* vs, blas_int* ldvs, double* work, blas_int* lwork, blas_int* bwork, blas_int* info); + + // Schur decomposition (complex matrices) + void arma_fortran(arma_cgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, void* a, blas_int* lda, blas_int* sdim, void* w, void* vs, blas_int* ldvs, void* work, blas_int* lwork, float* rwork, blas_int* bwork, blas_int* info); + void arma_fortran(arma_zgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, void* a, blas_int* lda, blas_int* sdim, void* w, void* vs, blas_int* ldvs, void* work, blas_int* lwork, double* rwork, blas_int* bwork, blas_int* info); + + // solve a Sylvester equation ax + xb = c, with a and b assumed to be in Schur form + void arma_fortran(arma_strsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const float* a, blas_int* lda, const float* b, blas_int* ldb, float* c, blas_int* ldc, float* scale, blas_int* info); + void arma_fortran(arma_dtrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const double* a, blas_int* lda, const double* b, blas_int* ldb, double* c, blas_int* ldc, double* scale, blas_int* info); + void arma_fortran(arma_ctrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const void* a, blas_int* lda, const void* b, blas_int* ldb, void* c, blas_int* ldc, float* scale, blas_int* info); + void arma_fortran(arma_ztrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const void* a, blas_int* lda, const void* b, blas_int* ldb, void* c, blas_int* ldc, double* scale, blas_int* info); + + void arma_fortran(arma_ssytrf)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_dsytrf)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_csytrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info); + void arma_fortran(arma_zsytrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info); + + void arma_fortran(arma_ssytri)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* info); + void arma_fortran(arma_dsytri)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* info); + void arma_fortran(arma_csytri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* info); + void arma_fortran(arma_zsytri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* info); + + // void arma_fortran(arma_dgeqp3)(blas_int* m, blas_int* n, double* a, blas_int* lda, blas_int* jpvt, double* tau, double* work, blas_int* lwork, blas_int* info); + // void arma_fortran(arma_dormqr)(char* side, char* trans, blas_int* m, blas_int* n, blas_int* k, double* a, blas_int* lda, double* tau, double* c, blas_int* ldc, double* work, blas_int* lwork, blas_int* info); + // void arma_fortran(arma_dposv)(char* uplo, blas_int* n, blas_int* nrhs, double* a, blas_int* lda, double* b, blas_int* ldb, blas_int* info); + } + + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/lapack_wrapper.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/lapack_wrapper.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,703 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2009 Edmund Highcock +// Copyright (C) 2011 James Sanders +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#ifdef ARMA_USE_LAPACK + + +//! \namespace lapack namespace for LAPACK functions +namespace lapack + { + + + template + inline + void + getrf(blas_int* m, blas_int* n, eT* a, blas_int* lda, blas_int* ipiv, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgetrf)(m, n, (T*)a, lda, ipiv, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgetrf)(m, n, (T*)a, lda, ipiv, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgetrf)(m, n, (T*)a, lda, ipiv, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgetrf)(m, n, (T*)a, lda, ipiv, info); + } + } + + + + template + inline + void + getri(blas_int* n, eT* a, blas_int* lda, blas_int* ipiv, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgetri)(n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgetri)(n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgetri)(n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgetri)(n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + } + + + + template + inline + void + trtri(char* uplo, char* diag, blas_int* n, eT* a, blas_int* lda, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_strtri)(uplo, diag, n, (T*)a, lda, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dtrtri)(uplo, diag, n, (T*)a, lda, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_ctrtri)(uplo, diag, n, (T*)a, lda, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_ztrtri)(uplo, diag, n, (T*)a, lda, info); + } + } + + + + template + inline + void + syev(char* jobz, char* uplo, blas_int* n, eT* a, blas_int* lda, eT* w, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_ssyev)(jobz, uplo, n, (T*)a, lda, (T*)w, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dsyev)(jobz, uplo, n, (T*)a, lda, (T*)w, (T*)work, lwork, info); + } + } + + + + template + inline + void + heev + ( + char* jobz, char* uplo, blas_int* n, + eT* a, blas_int* lda, typename eT::value_type* w, + eT* work, blas_int* lwork, typename eT::value_type* rwork, + blas_int* info + ) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_supported_complex_float::value == true) + { + typedef float T; + typedef typename std::complex cx_T; + arma_fortran(arma_cheev)(jobz, uplo, n, (cx_T*)a, lda, (T*)w, (cx_T*)work, lwork, (T*)rwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef double T; + typedef typename std::complex cx_T; + arma_fortran(arma_zheev)(jobz, uplo, n, (cx_T*)a, lda, (T*)w, (cx_T*)work, lwork, (T*)rwork, info); + } + } + + + template + inline + void + geev + ( + char* jobvl, char* jobvr, blas_int* n, + eT* a, blas_int* lda, eT* wr, eT* wi, eT* vl, + blas_int* ldvl, eT* vr, blas_int* ldvr, + eT* work, blas_int* lwork, + blas_int* info + ) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgeev)(jobvl, jobvr, n, (T*)a, lda, (T*)wr, (T*)wi, (T*)vl, ldvl, (T*)vr, ldvr, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgeev)(jobvl, jobvr, n, (T*)a, lda, (T*)wr, (T*)wi, (T*)vl, ldvl, (T*)vr, ldvr, (T*)work, lwork, info); + } + } + + + template + inline + void + cx_geev + ( + char* jobvl, char* jobvr, blas_int* n, + eT* a, blas_int* lda, eT* w, + eT* vl, blas_int* ldvl, + eT* vr, blas_int* ldvr, + eT* work, blas_int* lwork, typename eT::value_type* rwork, + blas_int* info + ) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_supported_complex_float::value == true) + { + typedef float T; + typedef typename std::complex cx_T; + arma_fortran(arma_cgeev)(jobvl, jobvr, n, (cx_T*)a, lda, (cx_T*)w, (cx_T*)vl, ldvl, (cx_T*)vr, ldvr, (cx_T*)work, lwork, (T*)rwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef double T; + typedef typename std::complex cx_T; + arma_fortran(arma_zgeev)(jobvl, jobvr, n, (cx_T*)a, lda, (cx_T*)w, (cx_T*)vl, ldvl, (cx_T*)vr, ldvr, (cx_T*)work, lwork, (T*)rwork, info); + } + } + + + + + template + inline + void + potrf(char* uplo, blas_int* n, eT* a, blas_int* lda, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_spotrf)(uplo, n, (T*)a, lda, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dpotrf)(uplo, n, (T*)a, lda, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cpotrf)(uplo, n, (T*)a, lda, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zpotrf)(uplo, n, (T*)a, lda, info); + } + + } + + + + template + inline + void + potri(char* uplo, blas_int* n, eT* a, blas_int* lda, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_spotri)(uplo, n, (T*)a, lda, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dpotri)(uplo, n, (T*)a, lda, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cpotri)(uplo, n, (T*)a, lda, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zpotri)(uplo, n, (T*)a, lda, info); + } + + } + + + + template + inline + void + geqrf(blas_int* m, blas_int* n, eT* a, blas_int* lda, eT* tau, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgeqrf)(m, n, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgeqrf)(m, n, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgeqrf)(m, n, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgeqrf)(m, n, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + + } + + + + template + inline + void + orgqr(blas_int* m, blas_int* n, blas_int* k, eT* a, blas_int* lda, eT* tau, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sorgqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dorgqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + } + + + + template + inline + void + ungqr(blas_int* m, blas_int* n, blas_int* k, eT* a, blas_int* lda, eT* tau, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_supported_complex_float::value == true) + { + typedef float T; + arma_fortran(arma_cungqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef double T; + arma_fortran(arma_zungqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); + } + } + + + template + inline + void + gesvd + ( + char* jobu, char* jobvt, blas_int* m, blas_int* n, eT* a, blas_int* lda, + eT* s, eT* u, blas_int* ldu, eT* vt, blas_int* ldvt, + eT* work, blas_int* lwork, blas_int* info + ) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgesvd)(jobu, jobvt, m, n, (T*)a, lda, (T*)s, (T*)u, ldu, (T*)vt, ldvt, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgesvd)(jobu, jobvt, m, n, (T*)a, lda, (T*)s, (T*)u, ldu, (T*)vt, ldvt, (T*)work, lwork, info); + } + } + + + + template + inline + void + cx_gesvd + ( + char* jobu, char* jobvt, blas_int* m, blas_int* n, std::complex* a, blas_int* lda, + T* s, std::complex* u, blas_int* ldu, std::complex* vt, blas_int* ldvt, + std::complex* work, blas_int* lwork, T* rwork, blas_int* info + ) + { + arma_type_check(( is_supported_blas_type::value == false )); + arma_type_check(( is_supported_blas_type< std::complex >::value == false )); + + if(is_float::value == true) + { + typedef float bT; + arma_fortran(arma_cgesvd) + ( + jobu, jobvt, m, n, (std::complex*)a, lda, + (bT*)s, (std::complex*)u, ldu, (std::complex*)vt, ldvt, + (std::complex*)work, lwork, (bT*)rwork, info + ); + } + else + if(is_double::value == true) + { + typedef double bT; + arma_fortran(arma_zgesvd) + ( + jobu, jobvt, m, n, (std::complex*)a, lda, + (bT*)s, (std::complex*)u, ldu, (std::complex*)vt, ldvt, + (std::complex*)work, lwork, (bT*)rwork, info + ); + } + } + + + + template + inline + void + gesv(blas_int* n, blas_int* nrhs, eT* a, blas_int* lda, blas_int* ipiv, eT* b, blas_int* ldb, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgesv)(n, nrhs, (T*)a, lda, ipiv, (T*)b, ldb, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgesv)(n, nrhs, (T*)a, lda, ipiv, (T*)b, ldb, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgesv)(n, nrhs, (T*)a, lda, ipiv, (T*)b, ldb, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgesv)(n, nrhs, (T*)a, lda, ipiv, (T*)b, ldb, info); + } + } + + + + template + inline + void + gels(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, eT* a, blas_int* lda, eT* b, blas_int* ldb, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgels)(trans, m, n, nrhs, (T*)a, lda, (T*)b, ldb, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgels)(trans, m, n, nrhs, (T*)a, lda, (T*)b, ldb, (T*)work, lwork, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_cgels)(trans, m, n, nrhs, (T*)a, lda, (T*)b, ldb, (T*)work, lwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zgels)(trans, m, n, nrhs, (T*)a, lda, (T*)b, ldb, (T*)work, lwork, info); + } + } + + + + template + inline + void + trtrs(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const eT* a, blas_int* lda, eT* b, blas_int* ldb, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_strtrs)(uplo, trans, diag, n, nrhs, (T*)a, lda, (T*)b, ldb, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dtrtrs)(uplo, trans, diag, n, nrhs, (T*)a, lda, (T*)b, ldb, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_ctrtrs)(uplo, trans, diag, n, nrhs, (T*)a, lda, (T*)b, ldb, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_ztrtrs)(uplo, trans, diag, n, nrhs, (T*)a, lda, (T*)b, ldb, info); + } + } + + + + template + inline + void + gees(char* jobvs, char* sort, blas_int* select, blas_int* n, eT* a, blas_int* lda, blas_int* sdim, eT* wr, eT* wi, eT* vs, blas_int* ldvs, eT* work, blas_int* lwork, blas_int* bwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_sgees)(jobvs, sort, select, n, (T*)a, lda, sdim, (T*)wr, (T*)wi, (T*)vs, ldvs, (T*)work, lwork, bwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dgees)(jobvs, sort, select, n, (T*)a, lda, sdim, (T*)wr, (T*)wi, (T*)vs, ldvs, (T*)work, lwork, bwork, info); + } + } + + + + template + inline + void + cx_gees(char* jobvs, char* sort, blas_int* select, blas_int* n, std::complex* a, blas_int* lda, blas_int* sdim, std::complex* w, std::complex* vs, blas_int* ldvs, std::complex* work, blas_int* lwork, T* rwork, blas_int* bwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + arma_type_check(( is_supported_blas_type< std::complex >::value == false )); + + if(is_float::value == true) + { + typedef float bT; + typedef std::complex cT; + arma_fortran(arma_cgees)(jobvs, sort, select, n, (cT*)a, lda, sdim, (cT*)w, (cT*)vs, ldvs, (cT*)work, lwork, (bT*)rwork, bwork, info); + } + else + if(is_double::value == true) + { + typedef double bT; + typedef std::complex cT; + arma_fortran(arma_zgees)(jobvs, sort, select, n, (cT*)a, lda, sdim, (cT*)w, (cT*)vs, ldvs, (cT*)work, lwork, (bT*)rwork, bwork, info); + } + } + + + + template + inline + void + trsyl(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const eT* a, blas_int* lda, const eT* b, blas_int* ldb, eT* c, blas_int* ldc, eT* scale, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_strsyl)(transa, transb, isgn, m, n, (T*)a, lda, (T*)b, ldb, (T*)c, ldc, (T*)scale, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dtrsyl)(transa, transb, isgn, m, n, (T*)a, lda, (T*)b, ldb, (T*)c, ldc, (T*)scale, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_ctrsyl)(transa, transb, isgn, m, n, (T*)a, lda, (T*)b, ldb, (T*)c, ldc, (float*)scale, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_ztrsyl)(transa, transb, isgn, m, n, (T*)a, lda, (T*)b, ldb, (T*)c, ldc, (double*)scale, info); + } + } + + + template + inline + void + sytrf(char* uplo, blas_int* n, eT* a, blas_int* lda, blas_int* ipiv, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_ssytrf)(uplo, n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dsytrf)(uplo, n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_csytrf)(uplo, n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zsytrf)(uplo, n, (T*)a, lda, ipiv, (T*)work, lwork, info); + } + } + + + template + inline + void + sytri(char* uplo, blas_int* n, eT* a, blas_int* lda, blas_int* ipiv, eT* work, blas_int* info) + { + arma_type_check(( is_supported_blas_type::value == false )); + + if(is_float::value == true) + { + typedef float T; + arma_fortran(arma_ssytri)(uplo, n, (T*)a, lda, ipiv, (T*)work, info); + } + else + if(is_double::value == true) + { + typedef double T; + arma_fortran(arma_dsytri)(uplo, n, (T*)a, lda, ipiv, (T*)work, info); + } + else + if(is_supported_complex_float::value == true) + { + typedef std::complex T; + arma_fortran(arma_csytri)(uplo, n, (T*)a, lda, ipiv, (T*)work, info); + } + else + if(is_supported_complex_double::value == true) + { + typedef std::complex T; + arma_fortran(arma_zsytri)(uplo, n, (T*)a, lda, ipiv, (T*)work, info); + } + } + + + } + + +#endif diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtGlueCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtGlueCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtGlueCube +//! @{ + + + +template +class mtGlueCube : public BaseCube > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + + arma_inline mtGlueCube(const T1& in_A, const T2& in_B); + arma_inline mtGlueCube(const T1& in_A, const T2& in_B, const uword in_aux_uword); + arma_inline ~mtGlueCube(); + + arma_aligned const T1& A; //!< first operand + arma_aligned const T2& B; //!< second operand + arma_aligned uword aux_uword; //!< storage of auxiliary data, uword format + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtGlueCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtGlueCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtGlueCube +//! @{ + + + +template +inline +mtGlueCube::mtGlueCube(const T1& in_A, const T2& in_B) + : A(in_A) + , B(in_B) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtGlueCube::mtGlueCube(const T1& in_A, const T2& in_B, const uword in_aux_uword) + : A(in_A) + , B(in_B) + , aux_uword(in_aux_uword) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtGlueCube::~mtGlueCube() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtGlue_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtGlue_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtGlue +//! @{ + + + +template +class mtGlue : public Base > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + + arma_inline mtGlue(const T1& in_A, const T2& in_B); + arma_inline mtGlue(const T1& in_A, const T2& in_B, const uword in_aux_uword); + arma_inline ~mtGlue(); + + arma_aligned const T1& A; //!< first operand + arma_aligned const T2& B; //!< second operand + arma_aligned uword aux_uword; //!< storage of auxiliary data, uword format + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtGlue_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtGlue_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,51 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtGlue +//! @{ + + + +template +inline +mtGlue::mtGlue(const T1& in_A, const T2& in_B) + : A(in_A) + , B(in_B) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtGlue::mtGlue(const T1& in_A, const T2& in_B, const uword in_aux_uword) + : A(in_A) + , B(in_B) + , aux_uword(in_aux_uword) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtGlue::~mtGlue() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtOpCube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtOpCube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,50 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtOpCube +//! @{ + + + +template +class mtOpCube : public BaseCube > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + + typedef typename T1::elem_type in_eT; + + inline explicit mtOpCube(const T1& in_m); + inline mtOpCube(const T1& in_m, const in_eT in_aux); + inline mtOpCube(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + inline mtOpCube(const T1& in_m, const in_eT in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c); + + inline mtOpCube(const char junk, const T1& in_m, const out_eT in_aux); + + inline ~mtOpCube(); + + + arma_aligned const T1& m; //!< storage of reference to the operand (eg. a matrix) + arma_aligned in_eT aux; //!< storage of auxiliary data, using the element type as used by T1 + arma_aligned out_eT aux_out_eT; //!< storage of auxiliary data, using the element type as specified by the out_eT template parameter + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_c; //!< storage of auxiliary data, uword format + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtOpCube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtOpCube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,88 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtOpCube +//! @{ + + + +template +inline +mtOpCube::mtOpCube(const T1& in_m) + : m(in_m) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOpCube::mtOpCube(const T1& in_m, const typename T1::elem_type in_aux) + : m(in_m) + , aux(in_aux) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOpCube::mtOpCube(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : m(in_m) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOpCube::mtOpCube(const T1& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b, const uword in_aux_uword_c) + : m(in_m) + , aux(in_aux) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + , aux_uword_c(in_aux_uword_c) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOpCube::mtOpCube(const char junk, const T1& in_m, const out_eT in_aux) + : m(in_m) + , aux_out_eT(in_aux) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + } + + + +template +inline +mtOpCube::~mtOpCube() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtOp_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtOp_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,49 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtOp +//! @{ + + + +template +class mtOp : public Base > + { + public: + + typedef out_eT elem_type; + typedef typename get_pod_type::result pod_type; + + typedef typename T1::elem_type in_eT; + + inline explicit mtOp(const T1& in_m); + inline mtOp(const T1& in_m, const in_eT in_aux); + inline mtOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b); + inline mtOp(const T1& in_m, const in_eT in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b); + + inline mtOp(const char junk, const T1& in_m, const out_eT in_aux); + + inline ~mtOp(); + + + arma_aligned const T1& m; //!< storage of reference to the operand (eg. a matrix) + arma_aligned in_eT aux; //!< storage of auxiliary data, using the element type as used by T1 + arma_aligned out_eT aux_out_eT; //!< storage of auxiliary data, using the element type as specified by the out_eT template parameter + arma_aligned uword aux_uword_a; //!< storage of auxiliary data, uword format + arma_aligned uword aux_uword_b; //!< storage of auxiliary data, uword format + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/mtOp_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/mtOp_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,87 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup mtOp +//! @{ + + + +template +inline +mtOp::mtOp(const T1& in_m) + : m(in_m) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOp::mtOp(const T1& in_m, const typename T1::elem_type in_aux) + : m(in_m) + , aux(in_aux) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOp::mtOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b) + : m(in_m) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOp::mtOp(const T1& in_m, const typename T1::elem_type in_aux, const uword in_aux_uword_a, const uword in_aux_uword_b) + : m(in_m) + , aux(in_aux) + , aux_uword_a(in_aux_uword_a) + , aux_uword_b(in_aux_uword_b) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOp::mtOp(const char junk, const T1& in_m, const out_eT in_aux) + : m(in_m) + , aux_out_eT(in_aux) + { + arma_ignore(junk); + + arma_extra_debug_sigprint(); + } + + + +template +inline +mtOp::~mtOp() + { + arma_extra_debug_sigprint(); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_chol_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_chol_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,30 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_chol +//! @{ + + + +class op_chol + { + public: + + template + inline static void apply(Mat& out, const Op& X); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_chol_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_chol_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_chol +//! @{ + + + +template +inline +void +op_chol::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + const bool status = auxlib::chol(out, X.m); + + if(status == false) + { + out.reset(); + arma_bad("chol(): failed to converge"); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cor_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cor_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,33 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_cor +//! @{ + + + +class op_cor + { + public: + + template inline static void direct_cor(Mat& out, const Mat& X, const uword norm_type); + template inline static void direct_cor(Mat< std::complex >& out, const Mat< std::complex >& X, const uword norm_type); + + template inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cor_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cor_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,114 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_cor +//! @{ + + + +template +inline +void +op_cor::direct_cor(Mat& out, const Mat& A, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(A.is_empty()) + { + out.reset(); + return; + } + + if(A.is_vec()) + { + out.set_size(1,1); + out[0] = eT(1); + } + else + { + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + const Row acc = sum(A); + const Row sd = stddev(A); + + out = (trans(A) * A); + out -= (trans(acc) * acc)/eT(N); + out /= norm_val; + out /= trans(sd) * sd; + } + } + + + +template +inline +void +op_cor::direct_cor(Mat< std::complex >& out, const Mat< std::complex >& A, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(A.is_empty()) + { + out.reset(); + return; + } + + if(A.is_vec()) + { + out.set_size(1,1); + out[0] = eT(1); + } + else + { + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + const Row acc = sum(A); + const Row sd = stddev(A); + + out = trans(A) * A; // out = strans(conj(A)) * A; + out -= (trans(acc) * acc)/eT(N); // out -= (strans(conj(acc)) * acc)/eT(N); + out /= norm_val; + + //out = out / (trans(sd) * sd); + out /= conv_to< Mat >::from(trans(sd) * sd); + } + } + + + +template +inline +void +op_cor::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& A = tmp.M; + + const uword norm_type = in.aux_uword_a; + + op_cor::direct_cor(out, A, norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cov_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cov_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,33 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_cov +//! @{ + + + +class op_cov + { + public: + + template inline static void direct_cov(Mat& out, const Mat& X, const uword norm_type); + template inline static void direct_cov(Mat< std::complex >& out, const Mat< std::complex >& X, const uword norm_type); + + template inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cov_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cov_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,112 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_cov +//! @{ + + + +template +inline +void +op_cov::direct_cov(Mat& out, const Mat& A, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(A.is_vec()) + { + if(A.n_rows == 1) + { + out = var(trans(A), norm_type); + } + else + { + out = var(A, norm_type); + } + } + else + { + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + const Row acc = sum(A); + + out = trans(A) * A; + out -= (trans(acc) * acc)/eT(N); + out /= norm_val; + } + } + + + +template +inline +void +op_cov::direct_cov(Mat< std::complex >& out, const Mat< std::complex >& A, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(A.is_vec()) + { + if(A.n_rows == 1) + { + const Mat tmp_mat = var(trans(A), norm_type); + out.set_size(1,1); + out[0] = tmp_mat[0]; + } + else + { + const Mat tmp_mat = var(A, norm_type); + out.set_size(1,1); + out[0] = tmp_mat[0]; + } + } + else + { + const uword N = A.n_rows; + const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N); + + const Row acc = sum(A); + + out = trans(A) * A; // out = strans(conj(A)) * A; + out -= (trans(acc) * acc)/eT(N); // out -= (strans(conj(acc)) * acc)/eT(N); + out /= norm_val; + } + } + + + +template +inline +void +op_cov::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& A = tmp.M; + + const uword norm_type = in.aux_uword_a; + + op_cov::direct_cov(out, A, norm_type); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cumsum_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cumsum_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,37 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_cumsum +//! @{ + + + +class op_cumsum_mat + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + + +class op_cumsum_vec + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cumsum_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cumsum_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,110 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_cumsum +//! @{ + + +template +inline +void +op_cumsum_mat::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "cumsum(): incorrect usage. dim must be 0 or 1"); + + out.copy_size(X); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) + { + arma_extra_debug_print("op_cumsum::apply(), dim = 0"); + + for(uword col=0; col +inline +void +op_cumsum_vec::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + const uword n_elem = X.n_elem; + + out.copy_size(X); + + eT* out_mem = out.memptr(); + const eT* X_mem = X.memptr(); + + eT acc = eT(0); + + for(uword i=0; i + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_times>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_times>& X + ); + + }; + + + +class op_cx_scalar_plus + { + public: + + template + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_plus>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_plus>& X + ); + + }; + + + +class op_cx_scalar_minus_pre + { + public: + + template + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_minus_pre>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_minus_pre>& X + ); + + }; + + + +class op_cx_scalar_minus_post + { + public: + + template + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_minus_post>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_minus_post>& X + ); + + }; + + + +class op_cx_scalar_div_pre + { + public: + + template + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_div_pre>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_div_pre>& X + ); + + }; + + + +class op_cx_scalar_div_post + { + public: + + template + inline static void + apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_div_post>& X + ); + + template + inline static void + apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_div_post>& X + ); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_cx_scalar_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_cx_scalar_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,385 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_cx_scalar +//! @{ + + + +template +inline +void +op_cx_scalar_times::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_times>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_plus::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_plus>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_minus_pre::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_minus_pre>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_minus_post::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_minus_post>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_div_pre::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_div_pre>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_div_post::apply + ( + Mat< typename std::complex >& out, + const mtOp, T1, op_cx_scalar_div_post>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_times::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_times>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_plus::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_plus>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_minus_pre::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_minus_pre>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_minus_post::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_minus_post>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_div_pre::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_div_pre>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_cx_scalar_div_post::apply + ( + Cube< typename std::complex >& out, + const mtOpCube, T1, op_cx_scalar_div_post>& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const eT k = X.aux_out_eT; + const uword n_elem = out.n_elem; + eT* out_mem = out.memptr(); + + for(uword i=0; i + inline static void apply(Mat& out, const Op& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_diagmat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_diagmat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,103 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_diagmat +//! @{ + + + +template +inline +void +op_diagmat::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(X.m); + const Mat& A = tmp.M; + + if(A.is_vec() == true) + { + // generate a diagonal matrix out of a vector + + const uword N = A.n_elem; + const eT* A_mem = A.memptr(); + + if(&out != &A) + { + // no aliasing + out.zeros(N,N); + + for(uword i=0; i tmp(A_mem, N); + + const eT* tmp_mem = tmp.memptr(); + + out.zeros(N,N); + + for(uword i=0; i + inline static void apply(Mat& out, const Op& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_diagvec_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_diagvec_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,38 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_diagvec +//! @{ + + + +template +inline +void +op_diagvec::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const sword id = (X.aux_uword_b > 0) ? -sword(X.aux_uword_a) : sword(X.aux_uword_a); + + const unwrap_check tmp(X.m, out); + const Mat& A = tmp.M; + + out = A.diag(id); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_dot_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_dot_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,81 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_dot +//! @{ + +//! \brief +//! dot product operation + +class op_dot + { + public: + + template + arma_hot arma_pure inline static eT direct_dot_arma(const uword n_elem, const eT* const A, const eT* const B); + + template + arma_hot arma_pure inline static typename arma_float_only::result + direct_dot(const uword n_elem, const eT* const A, const eT* const B); + + template + arma_hot arma_pure inline static typename arma_cx_only::result + direct_dot(const uword n_elem, const eT* const A, const eT* const B); + + template + arma_hot arma_pure inline static typename arma_integral_only::result + direct_dot(const uword n_elem, const eT* const A, const eT* const B); + + + template + arma_hot arma_pure inline static eT direct_dot(const uword n_elem, const eT* const A, const eT* const B, const eT* C); + + template + arma_hot arma_inline static typename T1::elem_type apply(const Base& X, const Base& Y); + + template + arma_hot inline static typename T1::elem_type apply_unwrap(const Base& X, const Base& Y); + + template + arma_hot inline static typename T1::elem_type apply_proxy (const Base& X, const Base& Y); + }; + + + +//! \brief +//! normalised dot product operation + +class op_norm_dot + { + public: + + template + arma_hot inline static typename T1::elem_type apply (const Base& X, const Base& Y); + + template + arma_hot inline static typename T1::elem_type apply_unwrap(const Base& X, const Base& Y); + }; + + + +class op_cdot + { + public: + + template + arma_hot arma_inline static typename T1::elem_type apply(const Base& X, const Base& Y); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_dot_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_dot_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,390 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_dot +//! @{ + + + + +//! for two arrays, generic version +template +arma_hot +arma_pure +inline +eT +op_dot::direct_dot_arma(const uword n_elem, const eT* const A, const eT* const B) + { + arma_extra_debug_sigprint(); + + eT val1 = eT(0); + eT val2 = eT(0); + + uword i, j; + + for(i=0, j=1; j +arma_hot +arma_pure +inline +typename arma_float_only::result +op_dot::direct_dot(const uword n_elem, const eT* const A, const eT* const B) + { + arma_extra_debug_sigprint(); + + if( n_elem <= (128/sizeof(eT)) ) + { + return op_dot::direct_dot_arma(n_elem, A, B); + } + else + { + #if defined(ARMA_USE_ATLAS) + { + arma_extra_debug_print("atlas::cblas_dot()"); + + return atlas::cblas_dot(n_elem, A, B); + } + #elif defined(ARMA_USE_BLAS) + { + arma_extra_debug_print("blas::dot()"); + + return blas::dot(n_elem, A, B); + } + #else + { + return op_dot::direct_dot_arma(n_elem, A, B); + } + #endif + } + } + + + +//! for two arrays, complex version +template +inline +arma_hot +arma_pure +typename arma_cx_only::result +op_dot::direct_dot(const uword n_elem, const eT* const A, const eT* const B) + { + #if defined(ARMA_USE_ATLAS) + { + arma_extra_debug_print("atlas::cx_cblas_dot()"); + + return atlas::cx_cblas_dot(n_elem, A, B); + } + #elif defined(ARMA_USE_BLAS) + { + // TODO: work out the mess with zdotu() and zdotu_sub() in BLAS + return op_dot::direct_dot_arma(n_elem, A, B); + } + #else + { + return op_dot::direct_dot_arma(n_elem, A, B); + } + #endif + } + + + +//! for two arrays, integral version +template +arma_hot +arma_pure +inline +typename arma_integral_only::result +op_dot::direct_dot(const uword n_elem, const eT* const A, const eT* const B) + { + return op_dot::direct_dot_arma(n_elem, A, B); + } + + + + +//! for three arrays +template +arma_hot +arma_pure +inline +eT +op_dot::direct_dot(const uword n_elem, const eT* const A, const eT* const B, const eT* C) + { + arma_extra_debug_sigprint(); + + eT val = eT(0); + + for(uword i=0; i +arma_hot +arma_inline +typename T1::elem_type +op_dot::apply(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + if( (is_Mat::value == true) && (is_Mat::value == true) ) + { + return op_dot::apply_unwrap(X,Y); + } + else + { + return op_dot::apply_proxy(X,Y); + } + } + + + +template +arma_hot +arma_inline +typename T1::elem_type +op_dot::apply_unwrap(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(X.get_ref()); + const unwrap tmp2(Y.get_ref()); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + arma_debug_check( (A.n_elem != B.n_elem), "dot(): objects must have the same number of elements" ); + + return op_dot::direct_dot(A.n_elem, A.mem, B.mem); + } + + + +template +arma_hot +inline +typename T1::elem_type +op_dot::apply_proxy(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const Proxy A(X.get_ref()); + const Proxy B(Y.get_ref()); + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor) && (Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + arma_debug_check( (A.get_n_elem() != B.get_n_elem()), "dot(): objects must have the same number of elements" ); + + const uword N = A.get_n_elem(); + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + + eT val1 = eT(0); + eT val2 = eT(0); + + uword i,j; + + for(i=0, j=1; j +arma_hot +inline +typename T1::elem_type +op_norm_dot::apply(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const bool prefer_at_accessor = (Proxy::prefer_at_accessor) && (Proxy::prefer_at_accessor); + + if(prefer_at_accessor == false) + { + const Proxy A(X.get_ref()); + const Proxy B(Y.get_ref()); + + arma_debug_check( (A.get_n_elem() != B.get_n_elem()), "norm_dot(): objects must have the same number of elements" ); + + const uword N = A.get_n_elem(); + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + + eT acc1 = eT(0); + eT acc2 = eT(0); + eT acc3 = eT(0); + + for(uword i=0; i +arma_hot +inline +typename T1::elem_type +op_norm_dot::apply_unwrap(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp1(X.get_ref()); + const unwrap tmp2(Y.get_ref()); + + const Mat& A = tmp1.M; + const Mat& B = tmp2.M; + + + arma_debug_check( (A.n_elem != B.n_elem), "norm_dot(): objects must have the same number of elements" ); + + const uword N = A.n_elem; + + const eT* A_mem = A.memptr(); + const eT* B_mem = B.memptr(); + + eT acc1 = eT(0); + eT acc2 = eT(0); + eT acc3 = eT(0); + + for(uword i=0; i +arma_hot +arma_inline +typename T1::elem_type +op_cdot::apply(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const Proxy A(X.get_ref()); + const Proxy B(Y.get_ref()); + + arma_debug_check( (A.get_n_elem() != B.get_n_elem()), "cdot(): objects must have the same number of elements" ); + + const uword N = A.get_n_elem(); + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + + eT val1 = eT(0); + eT val2 = eT(0); + + uword i,j; + for(i=0, j=1; j + inline static eT direct_rowvec_mat_colvec (const eT* A_mem, const Mat& B, const eT* C_mem); + + template + inline static eT direct_rowvec_transmat_colvec (const eT* A_mem, const Mat& B, const eT* C_mem); + + template + inline static eT direct_rowvec_diagmat_colvec (const eT* A_mem, const Mat& B, const eT* C_mem); + + template + inline static eT direct_rowvec_invdiagmat_colvec(const eT* A_mem, const Mat& B, const eT* C_mem); + + template + inline static eT direct_rowvec_invdiagvec_colvec(const eT* A_mem, const Mat& B, const eT* C_mem); + + }; + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_dotext_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_dotext_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,209 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_dotext +//! @{ + + + +template +inline +eT +op_dotext::direct_rowvec_mat_colvec + ( + const eT* A_mem, + const Mat& B, + const eT* C_mem + ) + { + arma_extra_debug_sigprint(); + + const uword cost_AB = B.n_cols; + const uword cost_BC = B.n_rows; + + if(cost_AB <= cost_BC) + { + podarray tmp(B.n_cols); + + for(uword col=0; col tmp(B.n_rows); + + for(uword row=0; row +inline +eT +op_dotext::direct_rowvec_transmat_colvec + ( + const eT* A_mem, + const Mat& B, + const eT* C_mem + ) + { + arma_extra_debug_sigprint(); + + const uword cost_AB = B.n_rows; + const uword cost_BC = B.n_cols; + + if(cost_AB <= cost_BC) + { + podarray tmp(B.n_rows); + + for(uword row=0; row tmp(B.n_cols); + + for(uword col=0; col +inline +eT +op_dotext::direct_rowvec_diagmat_colvec + ( + const eT* A_mem, + const Mat& B, + const eT* C_mem + ) + { + arma_extra_debug_sigprint(); + + eT val = eT(0); + + for(uword i=0; i +inline +eT +op_dotext::direct_rowvec_invdiagmat_colvec + ( + const eT* A_mem, + const Mat& B, + const eT* C_mem + ) + { + arma_extra_debug_sigprint(); + + eT val = eT(0); + + for(uword i=0; i +inline +eT +op_dotext::direct_rowvec_invdiagvec_colvec + ( + const eT* A_mem, + const Mat& B, + const eT* C_mem + ) + { + arma_extra_debug_sigprint(); + + const eT* B_mem = B.mem; + + eT val = eT(0); + + for(uword i=0; i + inline static uword + helper + ( + Mat& indices, + const Base& X + ); + + template + inline static uword + helper + ( + Mat& indices, + const mtOp& X, + const typename arma_op_rel_only::result junk1 = 0, + const typename arma_not_cx::result junk2 = 0 + ); + + template + inline static uword + helper + ( + Mat& indices, + const mtOp& X, + const typename arma_op_rel_only::result junk1 = 0, + const typename arma_cx_only::result junk2 = 0 + ); + + template + inline static uword + helper + ( + Mat& indices, + const mtGlue& X, + const typename arma_glue_rel_only::result junk1 = 0, + const typename arma_not_cx::result junk2 = 0, + const typename arma_not_cx::result junk3 = 0 + ); + + template + inline static uword + helper + ( + Mat& indices, + const mtGlue& X, + const typename arma_glue_rel_only::result junk1 = 0, + const typename arma_cx_only::result junk2 = 0, + const typename arma_cx_only::result junk3 = 0 + ); + + template + inline static void apply(Mat& out, const mtOp& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_find_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_find_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,321 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// Copyright (C) 2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_find +//! @{ + + + +template +inline +uword +op_find::helper + ( + Mat& indices, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type; + + const Proxy A(X.get_ref()); + + ea_type PA = A.get_ea(); + const uword n_elem = A.get_n_elem(); + + indices.set_size(n_elem, 1); + + uword* indices_mem = indices.memptr(); + uword n_nz = 0; + + for(uword i=0; i +inline +uword +op_find::helper + ( + Mat& indices, + const mtOp& X, + const typename arma_op_rel_only::result junk1, + const typename arma_not_cx::result junk2 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type; + + const eT val = X.aux; + + const Proxy A(X.m); + + ea_type PA = A.get_ea(); + const uword n_elem = A.get_n_elem(); + + indices.set_size(n_elem, 1); + + uword* indices_mem = indices.memptr(); + uword n_nz = 0; + + for(uword i=0; i::value == true) { not_zero = (val < tmp); } + else if(is_same_type::value == true) { not_zero = (tmp < val); } + else if(is_same_type::value == true) { not_zero = (val > tmp); } + else if(is_same_type::value == true) { not_zero = (tmp > val); } + else if(is_same_type::value == true) { not_zero = (val <= tmp); } + else if(is_same_type::value == true) { not_zero = (tmp <= val); } + else if(is_same_type::value == true) { not_zero = (val >= tmp); } + else if(is_same_type::value == true) { not_zero = (tmp >= val); } + else if(is_same_type::value == true) { not_zero = (tmp == val); } + else if(is_same_type::value == true) { not_zero = (tmp != val); } + else not_zero = false; + + if(not_zero == true) + { + indices_mem[n_nz] = i; + ++n_nz; + } + } + + return n_nz; + } + + + +template +inline +uword +op_find::helper + ( + Mat& indices, + const mtOp& X, + const typename arma_op_rel_only::result junk1, + const typename arma_cx_only::result junk2 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + + typedef typename T1::elem_type eT; + typedef typename Proxy::ea_type ea_type; + + const eT val = X.aux; + + const Proxy A(X.m); + + ea_type PA = A.get_ea(); + const uword n_elem = A.get_n_elem(); + + indices.set_size(n_elem, 1); + + uword* indices_mem = indices.memptr(); + uword n_nz = 0; + + for(uword i=0; i::value == true) { not_zero = (tmp == val); } + else if(is_same_type::value == true) { not_zero = (tmp != val); } + else not_zero = false; + + if(not_zero == true) + { + indices_mem[n_nz] = i; + ++n_nz; + } + } + + return n_nz; + } + + + +template +inline +uword +op_find::helper + ( + Mat& indices, + const mtGlue& X, + const typename arma_glue_rel_only::result junk1, + const typename arma_not_cx::result junk2, + const typename arma_not_cx::result junk3 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + arma_ignore(junk3); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "relational operator"); + + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + const uword n_elem = B.get_n_elem(); + + indices.set_size(n_elem, 1); + + uword* indices_mem = indices.memptr(); + uword n_nz = 0; + + for(uword i=0; i::value == true) { not_zero = (tmp1 < tmp2); } + else if(is_same_type::value == true) { not_zero = (tmp1 > tmp2); } + else if(is_same_type::value == true) { not_zero = (tmp1 <= tmp2); } + else if(is_same_type::value == true) { not_zero = (tmp1 >= tmp2); } + else if(is_same_type::value == true) { not_zero = (tmp1 == tmp2); } + else if(is_same_type::value == true) { not_zero = (tmp1 != tmp2); } + else not_zero = false; + + if(not_zero == true) + { + indices_mem[n_nz] = i; + ++n_nz; + } + } + + return n_nz; + } + + + +template +inline +uword +op_find::helper + ( + Mat& indices, + const mtGlue& X, + const typename arma_glue_rel_only::result junk1, + const typename arma_cx_only::result junk2, + const typename arma_cx_only::result junk3 + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk1); + arma_ignore(junk2); + arma_ignore(junk3); + + typedef typename Proxy::ea_type ea_type1; + typedef typename Proxy::ea_type ea_type2; + + const Proxy A(X.A); + const Proxy B(X.B); + + arma_debug_assert_same_size(A, B, "relational operator"); + + ea_type1 PA = A.get_ea(); + ea_type2 PB = B.get_ea(); + const uword n_elem = B.get_n_elem(); + + indices.set_size(n_elem, 1); + + uword* indices_mem = indices.memptr(); + uword n_nz = 0; + + for(uword i=0; i::value == true) { not_zero = (PA[i] == PB[i]); } + else if(is_same_type::value == true) { not_zero = (PA[i] != PB[i]); } + else not_zero = false; + + if(not_zero == true) + { + indices_mem[n_nz] = i; + ++n_nz; + } + } + + return n_nz; + } + + + +template +inline +void +op_find::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + const uword k = X.aux_uword_a; + const uword type = X.aux_uword_b; + + Mat indices; + const uword n_nz = op_find::helper(indices, X.m); + + if(n_nz > 0) + { + if(type == 0) // "first" + { + out = (k > 0 && k <= n_nz) ? indices.rows(0, k-1 ) : indices.rows(0, n_nz-1); + } + else // "last" + { + out = (k > 0 && k <= n_nz) ? indices.rows(n_nz-k, n_nz-1) : indices.rows(0, n_nz-1); + } + } + else + { + out.reset(); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_flip_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_flip_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,42 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_flip +//! @{ + + + +class op_flipud + { + public: + + template + inline static void apply(Mat& out, const Op& in); + + }; + + + + +class op_fliplr + { + public: + + template + inline static void apply(Mat& out, const Op& in); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_flip_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_flip_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,87 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_flip +//! @{ + + + +template +inline +void +op_flipud::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat X = tmp.M; + + if(&out != &X) + { + out.copy_size(X); + + for(uword i=0; i +inline +void +op_fliplr::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat X = tmp.M; + + if(&out != &X) + { + out.copy_size(X); + + for(uword i=0; i + arma_inline static void apply_noalias(Mat& out, const Mat& A, const typename arma_not_cx::result* junk = 0); + + template + inline static void apply_noalias(Mat& out, const Mat& A, const typename arma_cx_only::result* junk = 0); + + // + + template + arma_inline static void apply(Mat& out, const Mat& A, const typename arma_not_cx::result* junk = 0); + + template + inline static void apply(Mat& out, const Mat& A, const typename arma_cx_only::result* junk = 0); + + // + + template + inline static void apply(Mat& out, const Op& in); + + template + inline static void apply(Mat& out, const Op< Op, op_htrans>& in); + }; + + + +class op_htrans2 + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_htrans_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_htrans_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,177 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_htrans +//! @{ + + + +template +arma_inline +void +op_htrans::apply_noalias(Mat& out, const Mat& A, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + op_strans::apply_noalias(out, A); + } + + + +template +inline +void +op_htrans::apply_noalias(Mat& out, const Mat& A, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + out.set_size(A_n_cols, A_n_rows); + + for(uword in_row = 0; in_row < A_n_rows; ++in_row) + { + const uword out_col = in_row; + + for(uword in_col = 0; in_col < A_n_cols; ++in_col) + { + const uword out_row = in_col; + out.at(out_row, out_col) = std::conj( A.at(in_row, in_col) ); + } + } + + } + + + +template +arma_inline +void +op_htrans::apply(Mat& out, const Mat& A, const typename arma_not_cx::result* junk) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + op_strans::apply(out, A); + } + + + +template +inline +void +op_htrans::apply(Mat& out, const Mat& A, const typename arma_cx_only::result* junk) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + if(&out != &A) + { + op_htrans::apply_noalias(out, A); + } + else + { + if(out.n_rows == out.n_cols) + { + arma_extra_debug_print("doing in-place hermitian transpose of a square matrix"); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + for(uword col=0; col tmp; + op_strans::apply_noalias(tmp, A); + + out.steal_mem(tmp); + } + } + + } + + + +template +inline +void +op_htrans::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + op_htrans::apply(out, A); + } + + + +template +inline +void +op_htrans::apply(Mat& out, const Op< Op, op_htrans>& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m.m); + const Mat& A = tmp.M; + + const bool upper = in.m.aux_uword_a; + + op_trimat::apply_htrans(out, A, upper); + } + + + +template +inline +void +op_htrans2::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + + op_htrans::apply(out, tmp.M); + + arrayops::inplace_mul( out.memptr(), in.aux, out.n_elem ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_inv_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_inv_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,58 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_inv +//! @{ + + + +//! 'invert matrix' operation (general matrices) +class op_inv + { + public: + + template + inline static void apply(Mat& out, const Mat& A, const bool slow = false); + + template + inline static void apply(Mat& out, const Op& in); + + template + inline static void apply_diag(Mat& out, const Base& X); + }; + + + +//! 'invert matrix' operation (triangular matrices) +class op_inv_tr + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + + +//! 'invert matrix' operation (symmetric positive definite matrices) +class op_inv_sympd + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_inv_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_inv_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,139 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_inv +//! @{ + + +//! immediate inverse of a matrix, storing the result in a dense matrix +template +inline +void +op_inv::apply(Mat& out, const Mat& A, const bool slow) + { + arma_extra_debug_sigprint(); + + // no need to check for aliasing, due to: + // - auxlib::inv() copies A to out before inversion + // - for 2x2 and 3x3 matrices the code is alias safe + + bool status = auxlib::inv(out, A, slow); + + if(status == false) + { + out.reset(); + arma_bad("inv(): matrix appears to be singular"); + } + } + + + +//! immediate inverse of T1, storing the result in a dense matrix +template +inline +void +op_inv::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const strip_diagmat strip(X.m); + + if(strip.do_diagmat == true) + { + op_inv::apply_diag(out, strip.M); + } + else + { + const uword mode = X.aux_uword_a; + + const bool status = (mode == 0) ? auxlib::inv(out, X.m) : auxlib::inv(out, X.m, true); + + if(status == false) + { + out.reset(); + arma_bad("inv(): matrix appears to be singular"); + } + } + } + + + +template +inline +void +op_inv::apply_diag(Mat& out, const Base& X) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const diagmat_proxy_check A(X.get_ref(), out); + + const uword N = A.n_elem; + + out.set_size(N,N); + + for(uword col=0; col +inline +void +op_inv_tr::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + const bool status = auxlib::inv_tr(out, X.m, X.aux_uword_a); + + if(status == false) + { + out.reset(); + arma_bad("inv(): matrix appears to be singular"); + } + } + + + +//! inverse of T1 (symmetric positive definite matrices) +template +inline +void +op_inv_sympd::apply(Mat& out, const Op& X) + { + arma_extra_debug_sigprint(); + + const bool status = auxlib::inv_sympd(out, X.m, X.aux_uword_a); + + if(status == false) + { + out.reset(); + arma_bad("inv(): matrix appears to be singular"); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_max_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_max_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,65 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_max +//! @{ + + + +//! Class for finding maximum values in a matrix +class op_max + { + public: + + template + inline static eT direct_max(const eT* const X, const uword N); + + template + inline static eT direct_max(const eT* const X, const uword N, uword& index_of_max_val); + + template + inline static eT direct_max(const Mat& X, const uword row); + + template + inline static eT direct_max(const subview& X); + + template + inline static eT direct_max(const diagview& X); + + template + inline static void apply(Mat& out, const Op& in); + + + // + // for complex numbers + + template + inline static std::complex direct_max(const std::complex* const X, const uword n_elem); + + template + inline static std::complex direct_max(const std::complex* const X, const uword n_elem, uword& index_of_max_val); + + template + inline static std::complex direct_max(const Mat< std::complex >& X, const uword row); + + template + inline static std::complex direct_max(const subview< std::complex >& X); + + template + inline static std::complex direct_max(const diagview< std::complex >& X); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_max_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_max_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,386 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_max +//! @{ + + + +template +arma_pure +inline +eT +op_max::direct_max(const eT* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + eT max_val = priv::most_neg(); + + uword i,j; + + for(i=0, j=1; j max_val) + { + max_val = X_i; + } + + if(X_j > max_val) + { + max_val = X_j; + } + } + + + if(i < n_elem) + { + const eT X_i = X[i]; + + if(X_i > max_val) + { + max_val = X_i; + } + } + + return max_val; + } + + + +template +inline +eT +op_max::direct_max(const eT* const X, const uword n_elem, uword& index_of_max_val) + { + arma_extra_debug_sigprint(); + + eT max_val = priv::most_neg(); + + uword best_index = 0; + + uword i,j; + + for(i=0, j=1; j max_val) + { + max_val = X_i; + best_index = i; + } + + if(X_j > max_val) + { + max_val = X_j; + best_index = j; + } + } + + + if(i < n_elem) + { + const eT X_i = X[i]; + + if(X_i > max_val) + { + max_val = X_i; + best_index = i; + } + } + + index_of_max_val = best_index; + + return max_val; + } + + + +template +inline +eT +op_max::direct_max(const Mat& X, const uword row) + { + arma_extra_debug_sigprint(); + + const uword X_n_cols = X.n_cols; + + eT max_val = priv::most_neg(); + + for(uword col=0; col max_val) + { + max_val = tmp_val; + } + } + + return max_val; + } + + + +template +inline +eT +op_max::direct_max(const subview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + eT max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + } + } + + return max_val; + } + + + +template +inline +eT +op_max::direct_max(const diagview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + eT max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + } + } + + return max_val; + } + + + +//! \brief +//! For each row or for each column, find the maximum value. +//! The result is stored in a dense matrix that has either one column or one row. +//! The dimension, for which the maxima are found, is set via the max() function. +template +inline +void +op_max::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "max(): incorrect usage. dim must be 0 or 1"); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) + { + arma_extra_debug_print("op_max::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "max(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + eT* out_mem = out.memptr(); + + for(uword col=0; col +inline +std::complex +op_max::direct_max(const std::complex* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + uword index = 0; + T max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + index = i; + } + } + + return X[index]; + } + + + +template +inline +std::complex +op_max::direct_max(const std::complex* const X, const uword n_elem, uword& index_of_max_val) + { + arma_extra_debug_sigprint(); + + uword index = 0; + T max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + index = i; + } + } + + index_of_max_val = index; + + return X[index]; + } + + + +template +inline +std::complex +op_max::direct_max(const Mat< std::complex >& X, const uword row) + { + arma_extra_debug_sigprint(); + + const uword X_n_cols = X.n_cols; + + uword index = 0; + T max_val = priv::most_neg(); + + for(uword col=0; col max_val) + { + max_val = tmp_val; + index = col; + } + } + + return X.at(row,index); + } + + + +template +inline +std::complex +op_max::direct_max(const subview< std::complex >& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + uword index = 0; + T max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + index = i; + } + } + + return X[index]; + } + + + +template +inline +std::complex +op_max::direct_max(const diagview< std::complex >& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + uword index = 0; + T max_val = priv::most_neg(); + + for(uword i=0; i max_val) + { + max_val = tmp_val; + index = i; + } + } + + return X[index]; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_mean_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_mean_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,54 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_mean +//! @{ + + +//! Class for finding mean values of a matrix +class op_mean + { + public: + + template + inline static eT direct_mean(const eT* const X, const uword N); + + template + inline static eT direct_mean(const Mat& X, const uword row); + + template + inline static eT direct_mean(const subview& X); + + template + inline static eT direct_mean(const diagview& X); + + template + inline static void apply(Mat& out, const Op& in); + + + template + inline static eT direct_mean_robust(const eT* const X, const uword N); + + template + inline static eT direct_mean_robust(const Mat& X, const uword row); + + template + inline static eT direct_mean_robust(const subview& X); + + template + inline static eT direct_mean_robust(const diagview& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_mean_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_mean_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,279 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_mean +//! @{ + + + +template +arma_pure +inline +eT +op_mean::direct_mean(const eT* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const eT result = arrayops::accumulate(X, n_elem) / T(n_elem); + + return arma_isfinite(result) ? result : op_mean::direct_mean_robust(X, n_elem); + } + + + +template +inline +eT +op_mean::direct_mean(const Mat& X, const uword row) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_cols = X.n_cols; + + eT val = eT(0); + + for(uword col=0; col +inline +eT +op_mean::direct_mean(const subview& X) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_elem = X.n_elem; + + eT val = eT(0); + + for(uword i=0; i +inline +eT +op_mean::direct_mean(const diagview& X) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_elem = X.n_elem; + + eT val = eT(0); + + for(uword i=0; i +inline +void +op_mean::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + typedef typename get_pod_type::result T; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "mean(): incorrect usage. dim must be 0 or 1"); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) + { + arma_extra_debug_print("op_mean::apply(), dim = 0"); + + out.set_size( (X_n_rows > 0) ? 1 : 0, X_n_cols ); + + if(X_n_rows > 0) + { + eT* out_mem = out.memptr(); + + for(uword col=0; col 0) ? 1 : 0); + + if(X_n_cols > 0) + { + eT* out_mem = out.memptr(); + + for(uword row=0; row +arma_pure +inline +eT +op_mean::direct_mean_robust(const eT* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + // use an adapted form of the mean finding algorithm from the running_stat class + + typedef typename get_pod_type::result T; + + uword i,j; + + eT r_mean = eT(0); + + for(i=0, j=1; j +inline +eT +op_mean::direct_mean_robust(const Mat& X, const uword row) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_cols = X.n_cols; + + eT r_mean = eT(0); + + for(uword col=0; col +inline +eT +op_mean::direct_mean_robust(const subview& X) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_elem = X.n_elem; + + eT r_mean = eT(0); + + for(uword i=0; i +inline +eT +op_mean::direct_mean_robust(const diagview& X) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + const uword X_n_elem = X.n_elem; + + eT r_mean = eT(0); + + for(uword i=0; i +struct arma_cx_median_packet + { + T val; + uword index; + }; + + + +template +inline +bool +operator< (const arma_cx_median_packet& A, const arma_cx_median_packet& B) + { + return A.val < B.val; + } + + + +//! Class for finding median values of a matrix +class op_median + { + public: + + template + arma_inline static eT robust_mean(const eT A, const eT B); + + template + inline static eT direct_median(std::vector& X); + + template + inline static eT direct_median(const eT* X, const uword n_elem); + + template + inline static eT direct_median(const subview& X); + + template + inline static eT direct_median(const diagview& X); + + template + inline static void apply(Mat& out, const Op& in); + + + // + // for complex numbers + + template + arma_inline static std::complex robust_mean(const std::complex& A, const std::complex& B); + + template + inline static void direct_cx_median_index(uword& out_index1, uword& out_index2, std::vector< arma_cx_median_packet >& X); + + template + inline static void direct_cx_median_index(uword& out_index1, uword& out_index2, const std::complex* X, const uword n_elem); + + template + inline static void direct_cx_median_index(uword& out_index1, uword& out_index2, const subview< std::complex >& X); + + template + inline static void direct_cx_median_index(uword& out_index1, uword& out_index2, const diagview< std::complex >& X); + + template + inline static void apply(Mat< std::complex >& out, const Op& in); + + + }; + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_median_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_median_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,379 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_median +//! @{ + + + +template +arma_inline +eT +op_median::robust_mean(const eT A, const eT B) + { + return A + (B - A)/eT(2); + } + + + +//! find the median value of a std::vector (contents is modified) +template +inline +eT +op_median::direct_median(std::vector& X) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.size(); + const uword half = n_elem/2; + + std::sort(X.begin(), X.end()); + + if((n_elem % 2) == 0) + { + return op_median::robust_mean(X[half-1], X[half]); + } + else + { + return X[half]; + } + } + + + +template +inline +eT +op_median::direct_median(const eT* X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + std::vector tmp(X, X+n_elem); + + return op_median::direct_median(tmp); + } + + + +template +inline +eT +op_median::direct_median(const subview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + std::vector tmp(X_n_elem); + + for(uword i=0; i +inline +eT +op_median::direct_median(const diagview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + std::vector tmp(X_n_elem); + + for(uword i=0; i +inline +void +op_median::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "median(): incorrect usage. dim must be 0 or 1"); + + if(dim == 0) // in each column + { + arma_extra_debug_print("op_median::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "median(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + std::vector tmp_vec(X_n_rows); + + for(uword col=0; col tmp_vec(X_n_cols); + + for(uword row=0; row +arma_inline +std::complex +op_median::robust_mean(const std::complex& A, const std::complex& B) + { + return A + (B - A)/T(2); + } + + + +template +inline +void +op_median::direct_cx_median_index + ( + uword& out_index1, + uword& out_index2, + std::vector< arma_cx_median_packet >& X + ) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.size(); + const uword half = n_elem/2; + + std::sort(X.begin(), X.end()); + + if((n_elem % 2) == 0) + { + out_index1 = X[half-1].index; + out_index2 = X[half ].index; + } + else + { + out_index1 = X[half].index; + out_index2 = out_index1; + } + } + + + +template +inline +void +op_median::direct_cx_median_index + ( + uword& out_index1, + uword& out_index2, + const std::complex* X, + const uword n_elem + ) + { + arma_extra_debug_sigprint(); + + std::vector< arma_cx_median_packet > tmp(n_elem); + + for(uword i=0; i +inline +void +op_median::direct_cx_median_index + ( + uword& out_index1, + uword& out_index2, + const subview< std::complex >&X + ) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.n_elem; + + std::vector< arma_cx_median_packet > tmp(n_elem); + + for(uword i=0; i +inline +void +op_median::direct_cx_median_index + ( + uword& out_index1, + uword& out_index2, + const diagview< std::complex >&X + ) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.n_elem; + + std::vector< arma_cx_median_packet > tmp(n_elem); + + for(uword i=0; i +inline +void +op_median::apply(Mat< std::complex >& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + arma_type_check(( is_same_type::value == false )); + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "median(): incorrect usage. dim must be 0 or 1"); + + if(dim == 0) // in each column + { + arma_extra_debug_print("op_median::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "median(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + std::vector< arma_cx_median_packet > tmp_vec(X_n_rows); + + for(uword col=0; col > tmp_vec(X_n_cols); + + for(uword row=0; row + inline static eT direct_min(const eT* const X, const uword N); + + template + inline static eT direct_min(const eT* const X, const uword N, uword& index_of_min_val); + + template + inline static eT direct_min(const Mat& X, const uword row); + + template + inline static eT direct_min(const subview& X); + + template + inline static eT direct_min(const diagview& X); + + template + inline static void apply(Mat& out, const Op& in); + + + // + // for complex numbers + + template + inline static std::complex direct_min(const std::complex* const X, const uword n_elem); + + template + inline static std::complex direct_min(const std::complex* const X, const uword n_elem, uword& index_of_min_val); + + template + inline static std::complex direct_min(const Mat< std::complex >& X, const uword row); + + template + inline static std::complex direct_min(const subview< std::complex >&X); + + template + inline static std::complex direct_min(const diagview< std::complex >&X); + + }; + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_min_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_min_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,382 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_min +//! @{ + + + +template +arma_pure +inline +eT +op_min::direct_min(const eT* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + eT min_val = priv::most_pos(); + + uword i,j; + + for(i=0, j=1; j +inline +eT +op_min::direct_min(const eT* const X, const uword n_elem, uword& index_of_min_val) + { + arma_extra_debug_sigprint(); + + eT min_val = priv::most_pos(); + + uword best_index = 0; + + uword i,j; + + for(i=0, j=1; j +inline +eT +op_min::direct_min(const Mat& X, const uword row) + { + arma_extra_debug_sigprint(); + + const uword X_n_cols = X.n_cols; + + eT min_val = priv::most_pos(); + + for(uword col=0; col +inline +eT +op_min::direct_min(const subview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + eT min_val = priv::most_pos(); + + for(uword i=0; i +inline +eT +op_min::direct_min(const diagview& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + + eT min_val = priv::most_pos();; + + for(uword i=0; i +inline void op_min::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "min(): incorrect usage. dim must be 0 or 1"); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) // min in each column + { + arma_extra_debug_print("op_min::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "min(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + eT* out_mem = out.memptr(); + + for(uword col=0; col +inline +std::complex +op_min::direct_min(const std::complex* const X, const uword n_elem) + { + arma_extra_debug_sigprint(); + + uword index = 0; + T min_val = priv::most_pos(); + + for(uword i=0; i +inline +std::complex +op_min::direct_min(const std::complex* const X, const uword n_elem, uword& index_of_min_val) + { + arma_extra_debug_sigprint(); + + uword index = 0; + T min_val = priv::most_pos(); + + for(uword i=0; i +inline +std::complex +op_min::direct_min(const Mat< std::complex >& X, const uword row) + { + arma_extra_debug_sigprint(); + + const uword X_n_cols = X.n_cols; + + uword index = 0; + T min_val = priv::most_pos(); + + for(uword col=0; col +inline +std::complex +op_min::direct_min(const subview< std::complex >& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + uword index = 0; + T min_val = priv::most_pos(); + + for(uword i=0; i +inline +std::complex +op_min::direct_min(const diagview< std::complex >& X) + { + arma_extra_debug_sigprint(); + + const uword X_n_elem = X.n_elem; + uword index = 0; + T min_val = priv::most_pos(); + + for(uword i=0; i + inline static void apply( Mat& out, const mtOp& X); + + template + inline static void apply( Cube& out, const mtOpCube& X); + }; + + + +class op_imag + { + public: + + template + inline static void apply( Mat& out, const mtOp& X); + + template + inline static void apply( Cube& out, const mtOpCube& X); + }; + + + +class op_abs + { + public: + + template + inline static void apply( Mat& out, const mtOp& X); + + template + inline static void apply( Cube& out, const mtOpCube& X); + }; + + + +class op_sympd + { + public: + + template + inline static void apply( Mat& out, const Op& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_misc_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_misc_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,175 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_misc +//! @{ + + + +template +inline +void +op_real::apply( Mat& out, const mtOp& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_real::apply( Cube& out, const mtOpCube& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_imag::apply( Mat& out, const mtOp& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_imag::apply( Cube& out, const mtOpCube& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_abs::apply( Mat& out, const mtOp& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const Proxy A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_abs::apply( Cube& out, const mtOpCube& X ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::pod_type T; + + const ProxyCube A(X.m); + + out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); + + const uword n_elem = out.n_elem; + T* out_mem = out.memptr(); + + for(uword i=0; i +inline +void +op_sympd::apply( Mat& out, const Op& X ) + { + arma_extra_debug_sigprint(); + + out = X.m; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_pinv_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_pinv_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,32 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_pinv +//! @{ + + + +class op_pinv + { + public: + + template inline static void direct_pinv(Mat& out, const Mat& A, const eT in_tol); + + template inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_pinv_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_pinv_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,128 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_pinv +//! @{ + + + +template +inline +void +op_pinv::direct_pinv(Mat& out, const Mat& A, const eT in_tol) + { + arma_extra_debug_sigprint(); + + typedef typename get_pod_type::result T; + + T tol = access::tmp_real(in_tol); + + arma_debug_check((tol < T(0)), "pinv(): tolerance must be >= 0"); + + const uword n_rows = A.n_rows; + const uword n_cols = A.n_cols; + + // economical SVD decomposition + Mat U; + Col< T> s; + Mat V; + + const bool status = (n_cols > n_rows) ? auxlib::svd_econ(U,s,V,trans(A),'b') : auxlib::svd_econ(U,s,V,A,'b'); + + if(status == false) + { + out.reset(); + arma_bad("pinv(): svd failed"); + return; + } + + const uword s_n_elem = s.n_elem; + const T* s_mem = s.memptr(); + + // set tolerance to default if it hasn't been specified as an argument + if( (tol == T(0)) && (s_n_elem > 0) ) + { + tol = (std::max)(n_rows, n_cols) * eop_aux::direct_eps( op_max::direct_max(s_mem, s_n_elem) ); + } + + + // count non zero valued elements in s + + uword count = 0; + + for(uword i = 0; i < s_n_elem; ++i) + { + if(s_mem[i] > tol) + { + ++count; + } + } + + if(count != 0) + { + Col s2(count); + + T* s2_mem = s2.memptr(); + + uword count2 = 0; + + for(uword i=0; i < s_n_elem; ++i) + { + const T val = s_mem[i]; + + if(val > tol) + { + s2_mem[count2] = T(1) / val; + ++count2; + } + } + + + if(n_rows >= n_cols) + { + out = ( V.n_cols > count ? V.cols(0,count-1) : V ) * diagmat(s2) * trans( U.n_cols > count ? U.cols(0,count-1) : U ); + } + else + { + out = ( U.n_cols > count ? U.cols(0,count-1) : U ) * diagmat(s2) * trans( V.n_cols > count ? V.cols(0,count-1) : V ); + } + } + else + { + out.zeros(n_cols, n_rows); + } + } + + + +template +inline +void +op_pinv::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + op_pinv::direct_pinv(out, A, in.aux); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_princomp_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_princomp_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,114 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_princomp +//! @{ + + + +class op_princomp + { + public: + + // real element versions + + template + inline static bool + direct_princomp + ( + Mat& coeff_out, + const Mat& in + ); + + template + inline static bool + direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + const Mat& in + ); + + template + inline static bool + direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + const Mat& in + ); + + template + inline static bool + direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + Col& tsquared_out, + const Mat& in + ); + + + // complex element versions + + template + inline static bool + direct_princomp + ( + Mat< std::complex >& coeff_out, + const Mat< std::complex >& in + ); + + template + inline static bool + direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + const Mat< std::complex >& in + ); + + template + inline static bool + direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + Col& latent_out, + const Mat< std::complex >& in + ); + + template + inline static bool + direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + Col& latent_out, + Col< std::complex >& tsquared_out, + const Mat< std::complex >& in + ); + + + template + inline static void + apply(Mat& out, const Op& in); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_princomp_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_princomp_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,604 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2010 Dimitrios Bouzas +// Copyright (C) 2011 Stanislav Funiak +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_princomp +//! @{ + + + +//! \brief +//! principal component analysis -- 4 arguments version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +//! tsquared_out -> Hotelling's T^2 statistic +template +inline +bool +op_princomp::direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + Col& tsquared_out, + const Mat& in + ) + { + arma_extra_debug_sigprint(); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + + //U.reset(); // TODO: do we need this ? U will get automatically deleted anyway + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + + //Col s_tmp = zeros< Col >(n_cols); + Col s_tmp(n_cols); + s_tmp.zeros(); + + s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2); + s = s_tmp; + + // compute the Hotelling's T-squared + s_tmp.rows(0,n_rows-2) = eT(1) / s_tmp.rows(0,n_rows-2); + + const Mat S = score_out * diagmat(Col(s_tmp)); + tsquared_out = sum(S%S,1); + } + else + { + // compute the Hotelling's T-squared + const Mat S = score_out * diagmat(Col( eT(1) / s)); + tsquared_out = sum(S%S,1); + } + + // compute the eigenvalues of the principal vectors + latent_out = s%s; + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + + score_out.copy_size(in); + score_out.zeros(); + + latent_out.set_size(n_cols); + latent_out.zeros(); + + tsquared_out.set_size(n_rows); + tsquared_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 3 arguments version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +template +inline +bool +op_princomp::direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + Col& latent_out, + const Mat& in + ) + { + arma_extra_debug_sigprint(); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + + // U.reset(); + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + + Col s_tmp = zeros< Col >(n_cols); + s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2); + s = s_tmp; + } + + // compute the eigenvalues of the principal vectors + latent_out = s%s; + + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + + score_out.copy_size(in); + score_out.zeros(); + + latent_out.set_size(n_cols); + latent_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 2 arguments version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +template +inline +bool +op_princomp::direct_princomp + ( + Mat& coeff_out, + Mat& score_out, + const Mat& in + ) + { + arma_extra_debug_sigprint(); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + // U.reset(); + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + + Col s_tmp = zeros< Col >(n_cols); + s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2); + s = s_tmp; + } + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + score_out.copy_size(in); + score_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 1 argument version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +template +inline +bool +op_princomp::direct_princomp + ( + Mat& coeff_out, + const Mat& in + ) + { + arma_extra_debug_sigprint(); + + if(in.n_elem != 0) + { + // singular value decomposition + Mat U; + Col s; + + const Mat tmp = in - repmat(mean(in), in.n_rows, 1); + + const bool svd_ok = svd(U,s,coeff_out, tmp); + + if(svd_ok == false) + { + return false; + } + } + else + { + coeff_out.eye(in.n_cols, in.n_cols); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 4 arguments complex version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +//! tsquared_out -> Hotelling's T^2 statistic +template +inline +bool +op_princomp::direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + Col& latent_out, + Col< std::complex >& tsquared_out, + const Mat< std::complex >& in + ) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + + //U.reset(); + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + + Col s_tmp = zeros< Col >(n_cols); + s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2); + s = s_tmp; + + // compute the Hotelling's T-squared + s_tmp.rows(0,n_rows-2) = 1.0 / s_tmp.rows(0,n_rows-2); + const Mat S = score_out * diagmat(Col(s_tmp)); + tsquared_out = sum(S%S,1); + } + else + { + // compute the Hotelling's T-squared + const Mat S = score_out * diagmat(Col(T(1) / s)); + tsquared_out = sum(S%S,1); + } + + // compute the eigenvalues of the principal vectors + latent_out = s%s; + + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + + score_out.copy_size(in); + score_out.zeros(); + + latent_out.set_size(n_cols); + latent_out.zeros(); + + tsquared_out.set_size(n_rows); + tsquared_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 3 arguments complex version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +//! latent_out -> eigenvalues of principal vectors +template +inline +bool +op_princomp::direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + Col& latent_out, + const Mat< std::complex >& in + ) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col< T> s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + + // U.reset(); + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + + Col s_tmp = zeros< Col >(n_cols); + s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2); + s = s_tmp; + } + + // compute the eigenvalues of the principal vectors + latent_out = s%s; + + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + + score_out.copy_size(in); + score_out.zeros(); + + latent_out.set_size(n_cols); + latent_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 2 arguments complex version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +//! score_out -> projected samples +template +inline +bool +op_princomp::direct_princomp + ( + Mat< std::complex >& coeff_out, + Mat< std::complex >& score_out, + const Mat< std::complex >& in + ) + { + arma_extra_debug_sigprint(); + + typedef std::complex eT; + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows > 1) // more than one sample + { + // subtract the mean - use score_out as temporary matrix + score_out = in - repmat(mean(in), n_rows, 1); + + // singular value decomposition + Mat U; + Col< T> s; + + const bool svd_ok = svd(U,s,coeff_out,score_out); + + if(svd_ok == false) + { + return false; + } + + // U.reset(); + + // normalize the eigenvalues + s /= std::sqrt( double(n_rows - 1) ); + + // project the samples to the principals + score_out *= coeff_out; + + if(n_rows <= n_cols) // number of samples is less than their dimensionality + { + score_out.cols(n_rows-1,n_cols-1).zeros(); + } + + } + else // 0 or 1 samples + { + coeff_out.eye(n_cols, n_cols); + + score_out.copy_size(in); + score_out.zeros(); + } + + return true; + } + + + +//! \brief +//! principal component analysis -- 1 argument complex version +//! computation is done via singular value decomposition +//! coeff_out -> principal component coefficients +template +inline +bool +op_princomp::direct_princomp + ( + Mat< std::complex >& coeff_out, + const Mat< std::complex >& in + ) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(in.n_elem != 0) + { + // singular value decomposition + Mat U; + Col< T> s; + + const Mat tmp = in - repmat(mean(in), in.n_rows, 1); + + const bool svd_ok = svd(U,s,coeff_out, tmp); + + if(svd_ok == false) + { + return false; + } + } + else + { + coeff_out.eye(in.n_cols, in.n_cols); + } + + return true; + } + + + +template +inline +void +op_princomp::apply + ( + Mat& out, + const Op& in + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& A = tmp.M; + + const bool status = op_princomp::direct_princomp(out, A); + + if(status == false) + { + out.reset(); + + arma_bad("princomp(): failed to converge"); + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_prod_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_prod_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,27 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_prod +//! @{ + +//! Class for finding products of values in a matrix (e.g. along rows or columns) +class op_prod + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_prod_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_prod_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,72 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_prod +//! @{ + +//! \brief +//! Immediate product of elements of a matrix along a specified dimension (either rows or columns). +//! The result is stored in a dense matrix that has either one column or one row. +//! See the prod() function for more details. +template +inline +void +op_prod::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "prod(): incorrect usage. dim must be 0 or 1"); + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) // traverse across rows (i.e. find the product in each column) + { + out.set_size(1, X_n_cols); + + eT* out_mem = out.memptr(); + + for(uword col=0; col + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_lt_post + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_gt_pre + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_gt_post + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_lteq_pre + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_lteq_post + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_gteq_pre + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_gteq_post + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_eq + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +class op_rel_noteq + { + public: + + template + inline static void apply(Mat& out, const mtOp& X); + + template + inline static void apply(Cube& out, const mtOpCube& X); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_relational_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_relational_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,489 @@ +// Copyright (C) 2009-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_relational +//! @{ + + +#undef operator_rel + +#undef arma_applier_mat_pre +#undef arma_applier_mat_post + +#undef arma_applier_cube_pre +#undef arma_applier_cube_post + + +#define arma_applier_mat_pre(operator_rel) \ + {\ + typedef typename T1::elem_type eT;\ + typedef typename Proxy::ea_type ea_type;\ + \ + const eT val = X.aux;\ + \ + const Proxy P(X.m);\ + \ + const uword n_rows = P.get_n_rows();\ + const uword n_cols = P.get_n_cols();\ + \ + const bool bad_alias = ( Proxy::has_subview && P.is_alias(out) );\ + \ + if(bad_alias == false)\ + {\ + out.set_size(n_rows, n_cols);\ + \ + uword* out_mem = out.memptr();\ + \ + if(Proxy::prefer_at_accessor == false)\ + {\ + ea_type PA = P.get_ea();\ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp(P.Q);\ + \ + out = (val) operator_rel (tmp.M);\ + }\ + } + + + +#define arma_applier_mat_post(operator_rel) \ + {\ + typedef typename T1::elem_type eT;\ + typedef typename Proxy::ea_type ea_type;\ + \ + const eT val = X.aux;\ + \ + const Proxy P(X.m);\ + \ + const uword n_rows = P.get_n_rows();\ + const uword n_cols = P.get_n_cols();\ + \ + const bool bad_alias = ( Proxy::has_subview && P.is_alias(out) );\ + \ + if(bad_alias == false)\ + {\ + out.set_size(n_rows, n_cols);\ + \ + uword* out_mem = out.memptr();\ + \ + if(Proxy::prefer_at_accessor == false)\ + {\ + ea_type PA = P.get_ea();\ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp(P.Q);\ + \ + out = (tmp.M) operator_rel (val);\ + }\ + } + + + +#define arma_applier_cube_pre(operator_rel) \ + {\ + typedef typename T1::elem_type eT;\ + typedef typename ProxyCube::ea_type ea_type;\ + \ + const eT val = X.aux;\ + \ + const ProxyCube P(X.m);\ + \ + const uword n_rows = P.get_n_rows();\ + const uword n_cols = P.get_n_cols();\ + const uword n_slices = P.get_n_slices();\ + \ + const bool bad_alias = ( ProxyCube::has_subview && P.is_alias(out) );\ + \ + if(bad_alias == false)\ + {\ + out.set_size(n_rows, n_cols, n_slices);\ + \ + uword* out_mem = out.memptr();\ + \ + if(ProxyCube::prefer_at_accessor == false)\ + {\ + ea_type PA = P.get_ea();\ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp(P.Q);\ + \ + out = (val) operator_rel (tmp.M);\ + }\ + } + + + +#define arma_applier_cube_post(operator_rel) \ + {\ + typedef typename T1::elem_type eT;\ + typedef typename ProxyCube::ea_type ea_type;\ + \ + const eT val = X.aux;\ + \ + const ProxyCube P(X.m);\ + \ + const uword n_rows = P.get_n_rows();\ + const uword n_cols = P.get_n_cols();\ + const uword n_slices = P.get_n_slices();\ + \ + const bool bad_alias = ( ProxyCube::has_subview && P.is_alias(out) );\ + \ + if(bad_alias == false)\ + {\ + out.set_size(n_rows, n_cols, n_slices);\ + \ + uword* out_mem = out.memptr();\ + \ + if(ProxyCube::prefer_at_accessor == false)\ + {\ + ea_type PA = P.get_ea();\ + const uword n_elem = out.n_elem;\ + \ + for(uword i=0; i::stored_type> tmp(P.Q);\ + \ + out = (tmp.M) operator_rel (val);\ + }\ + } + + + +template +inline +void +op_rel_lt_pre::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_pre( < ); + } + + + +template +inline +void +op_rel_gt_pre::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_pre( > ); + } + + + +template +inline +void +op_rel_lteq_pre::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_pre( <= ); + } + + + +template +inline +void +op_rel_gteq_pre::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_pre( >= ); + } + + + +template +inline +void +op_rel_lt_post::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( < ); + } + + + +template +inline +void +op_rel_gt_post::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( > ); + } + + + +template +inline +void +op_rel_lteq_post::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( <= ); + } + + + +template +inline +void +op_rel_gteq_post::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( >= ); + } + + + +template +inline +void +op_rel_eq::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( == ); + } + + + +template +inline +void +op_rel_noteq::apply(Mat& out, const mtOp& X) + { + arma_extra_debug_sigprint(); + + arma_applier_mat_post( != ); + } + + + +// +// +// + + + +template +inline +void +op_rel_lt_pre::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_pre( < ); + } + + + +template +inline +void +op_rel_gt_pre::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_pre( > ); + } + + + +template +inline +void +op_rel_lteq_pre::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_pre( <= ); + } + + + +template +inline +void +op_rel_gteq_pre::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_pre( >= ); + } + + + +template +inline +void +op_rel_lt_post::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( < ); + } + + + +template +inline +void +op_rel_gt_post::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( > ); + } + + + +template +inline +void +op_rel_lteq_post::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( <= ); + } + + + +template +inline +void +op_rel_gteq_post::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( >= ); + } + + + +template +inline +void +op_rel_eq::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( == ); + } + + + +template +inline +void +op_rel_noteq::apply(Cube& out, const mtOpCube& X) + { + arma_extra_debug_sigprint(); + + arma_applier_cube_post( != ); + } + + + +#undef arma_applier_mat_pre +#undef arma_applier_mat_post + +#undef arma_applier_cube_pre +#undef arma_applier_cube_post + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_repmat_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_repmat_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,29 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_repmat +//! @{ + + + +class op_repmat + { + public: + template inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_repmat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_repmat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,60 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_repmat +//! @{ + + + +//! \brief +//! implementation of the 'repeat matrix' operation, used for constructing matrices +template +inline +void +op_repmat::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword copies_per_row = in.aux_uword_a; + const uword copies_per_col = in.aux_uword_b; + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + out.set_size(X_n_rows * copies_per_row, X_n_cols * copies_per_col); + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + + if( (out_n_rows > 0) && (out_n_cols > 0) ) + { + for(uword col = 0; col < out_n_cols; col += X_n_cols) + { + for(uword row = 0; row < out_n_rows; row += X_n_rows) + { + out.submat(row, col, row+X_n_rows-1, col+X_n_cols-1) = X; + } + } + } + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_reshape_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_reshape_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,30 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_reshape +//! @{ + + + +class op_reshape + { + public: + + template inline static void apply( Mat& out, const Op& in); + template inline static void apply(Cube& out, const OpCube& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_reshape_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_reshape_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,267 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_reshape +//! @{ + + + +template +inline +void +op_reshape::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + const uword in_n_rows = in.aux_uword_a; + const uword in_n_cols = in.aux_uword_b; + const uword in_dim = in.aux_uword_c; + + const uword in_n_elem = in_n_rows * in_n_cols; + + if(A.n_elem == in_n_elem) + { + if(in_dim == 0) + { + if(&out != &A) + { + out.set_size(in_n_rows, in_n_cols); + arrayops::copy( out.memptr(), A.memptr(), out.n_elem ); + } + else // &out == &A, i.e. inplace resize + { + const bool same_size = ( (out.n_rows == in_n_rows) && (out.n_cols == in_n_cols) ); + + if(same_size == false) + { + arma_debug_check + ( + (out.mem_state == 3), + "reshape(): size can't be changed as template based size specification is in use" + ); + + access::rw(out.n_rows) = in_n_rows; + access::rw(out.n_cols) = in_n_cols; + } + } + } + else + { + unwrap_check< Mat > tmp(A, out); + const Mat& B = tmp.M; + + out.set_size(in_n_rows, in_n_cols); + + eT* out_mem = out.memptr(); + uword i = 0; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + for(uword row=0; row > tmp(A, out); + const Mat& B = tmp.M; + + const uword n_elem_to_copy = (std::min)(B.n_elem, in_n_elem); + + out.set_size(in_n_rows, in_n_cols); + + eT* out_mem = out.memptr(); + + if(in_dim == 0) + { + arrayops::copy( out_mem, B.memptr(), n_elem_to_copy ); + } + else + { + uword row = 0; + uword col = 0; + + const uword B_n_cols = B.n_cols; + + for(uword i=0; i= B_n_cols) + { + col = 0; + ++row; + } + } + } + + for(uword i=n_elem_to_copy; i +inline +void +op_reshape::apply(Cube& out, const OpCube& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap_cube tmp(in.m); + const Cube& A = tmp.M; + + const uword in_n_rows = in.aux_uword_a; + const uword in_n_cols = in.aux_uword_b; + const uword in_n_slices = in.aux_uword_c; + const uword in_dim = in.aux_uword_d; + + const uword in_n_elem = in_n_rows * in_n_cols * in_n_slices; + + if(A.n_elem == in_n_elem) + { + if(in_dim == 0) + { + if(&out != &A) + { + out.set_size(in_n_rows, in_n_cols, in_n_slices); + arrayops::copy( out.memptr(), A.memptr(), out.n_elem ); + } + else // &out == &A, i.e. inplace resize + { + const bool same_size = ( (out.n_rows == in_n_rows) && (out.n_cols == in_n_cols) && (out.n_slices == in_n_slices) ); + + if(same_size == false) + { + arma_debug_check + ( + (out.mem_state == 3), + "reshape(): size can't be changed as template based size specification is in use" + ); + + out.delete_mat(); + + access::rw(out.n_rows) = in_n_rows; + access::rw(out.n_cols) = in_n_cols; + access::rw(out.n_elem_slice) = in_n_rows * in_n_cols; + access::rw(out.n_slices) = in_n_slices; + + out.create_mat(); + } + } + } + else + { + unwrap_cube_check< Cube > tmp(A, out); + const Cube& B = tmp.M; + + out.set_size(in_n_rows, in_n_cols, in_n_slices); + + eT* out_mem = out.memptr(); + uword i = 0; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + const uword B_n_slices = B.n_slices; + + for(uword slice=0; slice > tmp(A, out); + const Cube& B = tmp.M; + + const uword n_elem_to_copy = (std::min)(B.n_elem, in_n_elem); + + out.set_size(in_n_rows, in_n_cols, in_n_slices); + + eT* out_mem = out.memptr(); + + if(in_dim == 0) + { + arrayops::copy( out_mem, B.memptr(), n_elem_to_copy ); + } + else + { + uword row = 0; + uword col = 0; + uword slice = 0; + + const uword B_n_rows = B.n_rows; + const uword B_n_cols = B.n_cols; + + for(uword i=0; i= B_n_cols) + { + col = 0; + ++row; + + if(row >= B_n_rows) + { + row = 0; + ++slice; + } + } + } + } + + for(uword i=n_elem_to_copy; i inline static void apply( Mat& out, const Op& in); + template inline static void apply(Cube& out, const OpCube& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_resize_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_resize_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,119 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_resize +//! @{ + + + +template +inline +void +op_resize::apply(Mat& actual_out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword out_n_rows = in.aux_uword_a; + const uword out_n_cols = in.aux_uword_b; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + + Mat B; + + const bool alias = (&actual_out == &A); + + Mat& out = alias ? B : actual_out; + + out.set_size(out_n_rows, out_n_cols); + + if( (out_n_rows > A_n_rows) || (out_n_cols > A_n_cols) ) + { + out.zeros(); + } + + if( (out.n_elem > 0) && (A.n_elem > 0) ) + { + const uword end_row = (std::min)(out_n_rows, A_n_rows) - 1; + const uword end_col = (std::min)(out_n_cols, A_n_cols) - 1; + + out.submat(0, 0, end_row, end_col) = A.submat(0, 0, end_row, end_col); + } + + if(alias) + { + actual_out.steal_mem(B); + } + + } + + + +template +inline +void +op_resize::apply(Cube& actual_out, const OpCube& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const uword out_n_rows = in.aux_uword_a; + const uword out_n_cols = in.aux_uword_b; + const uword out_n_slices = in.aux_uword_c; + + const unwrap_cube tmp(in.m); + const Cube& A = tmp.M; + + const uword A_n_rows = A.n_rows; + const uword A_n_cols = A.n_cols; + const uword A_n_slices = A.n_slices; + + Cube B; + + const bool alias = (&actual_out == &A); + + Cube& out = alias ? B : actual_out; + + out.set_size(out_n_rows, out_n_cols, out_n_slices); + + if( (out_n_rows > A_n_rows) || (out_n_cols > A_n_cols) || (out_n_slices > A_n_slices) ) + { + out.zeros(); + } + + if( (out.n_elem > 0) && (A.n_elem > 0) ) + { + const uword end_row = (std::min)(out_n_rows, A_n_rows) - 1; + const uword end_col = (std::min)(out_n_cols, A_n_cols) - 1; + const uword end_slice = (std::min)(out_n_slices, A_n_slices) - 1; + + out.subcube(0, 0, 0, end_row, end_col, end_slice) = A.subcube(0, 0, 0, end_row, end_col, end_slice); + } + + if(alias) + { + actual_out.steal_mem(B); + } + + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_shuffle_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_shuffle_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,30 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_shuffle +//! @{ + + + +class op_shuffle + { + public: + + template inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_shuffle_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_shuffle_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,210 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// Copyright (C) 2009-2010 Dimitrios Bouzas +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup op_shuffle +//! @{ + + + +template +inline +void +op_shuffle::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + if(X.is_empty()) + { + out.copy_size(X); + return; + } + + const uword dim = in.aux_uword_a; + const uword N = (dim == 0) ? X.n_rows : X.n_cols; + + // see "fn_sort_index.hpp" for the definition of "arma_sort_index_packet_ascend" + // and the associated "operator<" + std::vector< arma_sort_index_packet_ascend > packet_vec(N); + + for(uword i=0; i 1) // i.e. column vector + { + for(uword i=0; i 1) // i.e. row vector + { + for(uword i=0; i 1) // i.e. column vector + { + for(uword i=0; i 1) // i.e. row vector + { + for(uword i=0; i + inline static void copy_row(eT* X, const Mat& A, const uword row); + + template + inline static void copy_row(Mat& A, const eT* X, const uword row); + + template + inline static void direct_sort(eT* X, const uword N, const uword sort_type = 0); + + template + inline static void apply(Mat& out, const Op& in); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_sort_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_sort_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,227 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_sort +//! @{ + + + +template +class arma_ascend_sort_helper + { + public: + + arma_inline + bool + operator() (eT a, eT b) const + { + return (a < b); + } + }; + + + +template +class arma_descend_sort_helper + { + public: + + arma_inline + bool + operator() (eT a, eT b) const + { + return (a > b); + } + }; + + + +template +class arma_ascend_sort_helper< std::complex > + { + public: + + typedef typename std::complex eT; + + inline + bool + operator() (const eT& a, const eT& b) const + { + return (std::abs(a) < std::abs(b)); + } + }; + + + +template +class arma_descend_sort_helper< std::complex > + { + public: + + typedef typename std::complex eT; + + inline + bool + operator() (const eT& a, const eT& b) const + { + return (std::abs(a) > std::abs(b)); + } + }; + + + +template +inline +void +op_sort::direct_sort(eT* X, const uword n_elem, const uword sort_type) + { + arma_extra_debug_sigprint(); + + if(sort_type == 0) + { + arma_ascend_sort_helper comparator; + + std::sort(&X[0], &X[n_elem], comparator); + } + else + { + arma_descend_sort_helper comparator; + + std::sort(&X[0], &X[n_elem], comparator); + } + } + + + +template +inline +void +op_sort::copy_row(eT* X, const Mat& A, const uword row) + { + const uword N = A.n_cols; + + uword i,j; + + for(i=0, j=1; j +inline +void +op_sort::copy_row(Mat& A, const eT* X, const uword row) + { + const uword N = A.n_cols; + + uword i,j; + + for(i=0, j=1; j +inline +void +op_sort::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& X = tmp.M; + + const uword sort_type = in.aux_uword_a; + const uword dim = in.aux_uword_b; + + arma_debug_check( (sort_type > 1), "sort(): incorrect usage. sort_type must be 0 or 1"); + arma_debug_check( (dim > 1), "sort(): incorrect usage. dim must be 0 or 1" ); + arma_debug_check( (X.is_finite() == false), "sort(): given object has non-finite elements" ); + + if( (X.n_rows * X.n_cols) <= 1 ) + { + out = X; + return; + } + + + if(dim == 0) // sort the contents of each column + { + arma_extra_debug_print("op_sort::apply(), dim = 0"); + + out = X; + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + for(uword col=0; col < n_cols; ++col) + { + op_sort::direct_sort( out.colptr(col), n_rows, sort_type ); + } + } + else + if(dim == 1) // sort the contents of each row + { + if(X.n_rows == 1) // a row vector + { + arma_extra_debug_print("op_sort::apply(), dim = 1, vector specific"); + + out = X; + op_sort::direct_sort(out.memptr(), out.n_elem, sort_type); + } + else // not a row vector + { + arma_extra_debug_print("op_sort::apply(), dim = 1, generic"); + + out.copy_size(X); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + podarray tmp_array(n_cols); + + for(uword row=0; row < n_rows; ++row) + { + op_sort::copy_row(tmp_array.memptr(), X, row); + + op_sort::direct_sort( tmp_array.memptr(), n_cols, sort_type ); + + op_sort::copy_row(out, tmp_array.memptr(), row); + } + } + } + + } + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_stddev_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_stddev_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,26 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_stddev +//! @{ + +//! Class for finding the standard deviation +class op_stddev + { + public: + + template + inline static void apply(Mat& out, const mtOp& in); + }; + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_stddev_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_stddev_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,85 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_stddev +//! @{ + + +//! \brief +//! For each row or for each column, find the standard deviation. +//! The result is stored in a dense matrix that has either one column or one row. +//! The dimension for which the standard deviations are found is set via the stddev() function. +template +inline +void +op_stddev::apply(Mat& out, const mtOp& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type in_eT; + typedef typename T1::pod_type out_eT; + + const unwrap_check_mixed tmp(in.m, out); + const Mat& X = tmp.M; + + const uword norm_type = in.aux_uword_a; + const uword dim = in.aux_uword_b; + + arma_debug_check( (norm_type > 1), "stddev(): incorrect usage. norm_type must be 0 or 1"); + arma_debug_check( (dim > 1), "stddev(): incorrect usage. dim must be 0 or 1" ); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) + { + arma_extra_debug_print("op_stddev::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "stddev(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + out_eT* out_mem = out.memptr(); + + for(uword col=0; col tmp(X_n_cols); + + in_eT* tmp_mem = tmp.memptr(); + out_eT* out_mem = out.memptr(); + + for(uword row=0; row + struct pos + { + static const uword n2 = (do_flip == false) ? (row + col*2) : (col + row*2); + static const uword n3 = (do_flip == false) ? (row + col*3) : (col + row*3); + static const uword n4 = (do_flip == false) ? (row + col*4) : (col + row*4); + }; + + template + inline static void apply_noalias_tinysq(Mat& out, const Mat& A); + + template + inline static void apply_noalias(Mat& out, const Mat& A); + + template + inline static void apply(Mat& out, const Mat& A); + + template + inline static void apply(Mat& out, const Op& in); + + + // inline static void apply_inplace(mat &out); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_strans_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_strans_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,258 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_strans +//! @{ + + + +//! for tiny square matrices (size <= 4x4) +template +inline +void +op_strans::apply_noalias_tinysq(Mat& out, const Mat& A) + { + const eT* Am = A.memptr(); + eT* outm = out.memptr(); + + switch(A.n_rows) + { + case 1: + { + outm[0] = Am[0]; + } + break; + + case 2: + { + outm[pos::n2] = Am[pos::n2]; + outm[pos::n2] = Am[pos::n2]; + + outm[pos::n2] = Am[pos::n2]; + outm[pos::n2] = Am[pos::n2]; + } + break; + + case 3: + { + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + outm[pos::n3] = Am[pos::n3]; + } + break; + + case 4: + { + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + outm[pos::n4] = Am[pos::n4]; + } + break; + + default: + ; + } + + } + + + +//! Immediate transpose of a dense matrix +template +inline +void +op_strans::apply_noalias(Mat& out, const Mat& A) + { + arma_extra_debug_sigprint(); + + const uword A_n_cols = A.n_cols; + const uword A_n_rows = A.n_rows; + + out.set_size(A_n_cols, A_n_rows); + + if( (A_n_cols == 1) || (A_n_rows == 1) ) + { + arrayops::copy( out.memptr(), A.mem, A.n_elem ); + } + else + { + if( (A_n_rows <= 4) && (A_n_rows == A_n_cols) ) + { + op_strans::apply_noalias_tinysq(out, A); + } + else + { + for(uword k=0; k < A_n_cols; ++k) + { + uword i, j; + + const eT* colptr = A.colptr(k); + + for(i=0, j=1; j < A_n_rows; i+=2, j+=2) + { + const eT tmp_i = colptr[i]; + const eT tmp_j = colptr[j]; + + out.at(k, i) = tmp_i; + out.at(k, j) = tmp_j; + } + + if(i < A_n_rows) + { + out.at(k, i) = colptr[i]; + } + } + } + } + } + + + +template +inline +void +op_strans::apply(Mat& out, const Mat& A) + { + arma_extra_debug_sigprint(); + + if(&out != &A) + { + op_strans::apply_noalias(out, A); + } + else + { + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + + if(n_rows == n_cols) + { + arma_extra_debug_print("op_strans::apply(): doing in-place transpose of a square matrix"); + + const uword N = n_rows; + + for(uword k=0; k < N; ++k) + { + eT* colptr = out.colptr(k); + + uword i,j; + + for(i=(k+1), j=(k+2); j < N; i+=2, j+=2) + { + std::swap(out.at(k,i), colptr[i]); + std::swap(out.at(k,j), colptr[j]); + } + + if(i < N) + { + std::swap(out.at(k,i), colptr[i]); + } + } + } + else + { + Mat tmp; + op_strans::apply_noalias(tmp, A); + + out.steal_mem(tmp); + } + } + } + + + +template +inline +void +op_strans::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + op_strans::apply(out, A); + } + + + +// inline void op_strans::apply_inplace(mat &X) +// { +// arma_extra_debug_sigprint(); +// +// if((X.n_rows == 1) || (X.n_cols == 1)) +// { +// const uword old_n_rows = X.n_rows; +// access::rw(X.n_rows) = X.n_cols; +// access::rw(X.n_cols) = old_n_rows; +// } +// else +// if(X.n_rows == X.n_cols) +// { +// for(uword col=0; col < X.n_cols; ++col) +// { +// double* X_coldata = X.colptr(col); +// +// for(uword row=(col+1); row < X.n_rows; ++row) +// { +// std::swap( A.at(col,row), A_coldata[row] ); +// } +// } +// } +// else +// { +// mat tmp = trans(X); +// +// if(X.mem != X.mem_local) +// { +// double* old_mem = X.memptr(); +// access::rw(X.mem) = tmp.memptr(); +// access::rw(tmp.mem) = old_mem; +// } +// else +// { +// X = tmp; +// } +// } +// +// } + + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_sum_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_sum_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,27 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_sum +//! @{ + +//! Class for finding sums of values in a matrix (e.g. along rows or columns) +class op_sum + { + public: + + template + inline static void apply(Mat& out, const Op& in); + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_sum_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_sum_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,72 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_sum +//! @{ + +//! \brief +//! Immediate sum of elements of a matrix along a specified dimension (either rows or columns). +//! The result is stored in a dense matrix that has either one column or one row. +//! See the sum() function for more details. +template +inline +void +op_sum::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + const uword dim = in.aux_uword_a; + arma_debug_check( (dim > 1), "sum(): incorrect usage. dim must be 0 or 1"); + + typedef typename T1::elem_type eT; + + const unwrap_check tmp(in.m, out); + const Mat& X = tmp.M; + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) // traverse across rows (i.e. find the sum in each column) + { + out.set_size(1, X_n_cols); + + eT* out_mem = out.memptr(); + + for(uword col=0; col + inline static void apply(Mat& out, const Op& in, const typename arma_not_cx::result* junk = 0); + + template + inline static void apply(Mat& out, const Op& in, const typename arma_cx_only::result* junk = 0); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_symmat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_symmat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,191 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_symmat +//! @{ + + + +template +inline +void +op_symmat::apply + ( + Mat& out, + const Op& in, + const typename arma_not_cx::result* junk + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_square() == false), "symmatu()/symmatl(): given matrix must be square" ); + + const uword N = A.n_rows; + const bool upper = (in.aux_uword_a == 0); + + if(&out != &A) + { + out.copy_size(A); + + if(upper) + { + // upper triangular: copy the diagonal and the elements above the diagonal + + for(uword i=0; i +inline +void +op_symmat::apply + ( + Mat& out, + const Op& in, + const typename arma_cx_only::result* junk + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_square() == false), "symmatu()/symmatl(): given matrix must be square" ); + + const uword N = A.n_rows; + const bool upper = (in.aux_uword_a == 0); + + if(&out != &A) + { + out.copy_size(A); + + if(upper) + { + // upper triangular: copy the diagonal and the elements above the diagonal + + for(uword i=0; i + inline static void fill_zeros(Mat& A, const bool upper); + + // + + template + inline static void apply(Mat& out, const Op& in); + + template + inline static void apply(Mat& out, const Op, op_trimat>& in); + + // + + template + inline static void apply_htrans(Mat& out, const Mat& A, const bool upper, const typename arma_not_cx::result* junk = 0); + + template + inline static void apply_htrans(Mat& out, const Mat& A, const bool upper, const typename arma_cx_only::result* junk = 0); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_trimat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_trimat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,248 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// Copyright (C) 2011 Ryan Curtin +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_trimat +//! @{ + + + +template +inline +void +op_trimat::fill_zeros(Mat& out, const bool upper) + { + arma_extra_debug_sigprint(); + + const uword N = out.n_rows; + + if(upper) + { + // upper triangular: set all elements below the diagonal to zero + + for(uword i=0; i +inline +void +op_trimat::apply(Mat& out, const Op& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m); + const Mat& A = tmp.M; + + arma_debug_check( (A.is_square() == false), "trimatu()/trimatl(): given matrix must be square" ); + + const uword N = A.n_rows; + const bool upper = (in.aux_uword_a == 0); + + if(&out != &A) + { + out.copy_size(A); + + if(upper) + { + // upper triangular: copy the diagonal and the elements above the diagonal + for(uword i=0; i +inline +void +op_trimat::apply(Mat& out, const Op, op_trimat>& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT; + + const unwrap tmp(in.m.m); + const Mat& A = tmp.M; + + const bool upper = (in.aux_uword_a == 0); + + op_trimat::apply_htrans(out, A, upper); + } + + + +template +inline +void +op_trimat::apply_htrans + ( + Mat& out, + const Mat& A, + const bool upper, + const typename arma_not_cx::result* junk + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + // This specialisation is for trimatl(trans(X)) = trans(trimatu(X)) and also + // trimatu(trans(X)) = trans(trimatl(X)). We want to avoid the creation of an + // extra temporary. + + // It doesn't matter if the input and output matrices are the same; we will + // pull data from the upper or lower triangular to the lower or upper + // triangular (respectively) and then set the rest to 0, so overwriting issues + // aren't present. + + arma_debug_check( (A.is_square() == false), "trimatu()/trimatl(): given matrix must be square" ); + + const uword N = A.n_rows; + + if(&out != &A) + { + out.copy_size(A); + } + + // We can't really get away with any array copy operations here, + // unfortunately... + + if(upper) + { + // Upper triangular: but since we're transposing, we're taking the lower + // triangular and putting it in the upper half. + for(uword row = 0; row < N; ++row) + { + eT* out_colptr = out.colptr(row); + + for(uword col = 0; col <= row; ++col) + { + //out.at(col, row) = A.at(row, col); + out_colptr[col] = A.at(row, col); + } + } + } + else + { + // Lower triangular: but since we're transposing, we're taking the upper + // triangular and putting it in the lower half. + for(uword row = 0; row < N; ++row) + { + for(uword col = row; col < N; ++col) + { + out.at(col, row) = A.at(row, col); + } + } + } + + op_trimat::fill_zeros(out, upper); + } + + + +template +inline +void +op_trimat::apply_htrans + ( + Mat& out, + const Mat& A, + const bool upper, + const typename arma_cx_only::result* junk + ) + { + arma_extra_debug_sigprint(); + arma_ignore(junk); + + arma_debug_check( (A.is_square() == false), "trimatu()/trimatl(): given matrix must be square" ); + + const uword N = A.n_rows; + + if(&out != &A) + { + out.copy_size(A); + } + + if(upper) + { + // Upper triangular: but since we're transposing, we're taking the lower + // triangular and putting it in the upper half. + for(uword row = 0; row < N; ++row) + { + eT* out_colptr = out.colptr(row); + + for(uword col = 0; col <= row; ++col) + { + //out.at(col, row) = std::conj( A.at(row, col) ); + out_colptr[col] = std::conj( A.at(row, col) ); + } + } + } + else + { + // Lower triangular: but since we're transposing, we're taking the upper + // triangular and putting it in the lower half. + for(uword row = 0; row < N; ++row) + { + for(uword col = row; col < N; ++col) + { + out.at(col, row) = std::conj( A.at(row, col) ); + } + } + } + + op_trimat::fill_zeros(out, upper); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_var_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_var_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,54 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_var +//! @{ + + + +//! Class for finding variance values of a matrix +class op_var + { + public: + + template + inline static eT direct_var(const eT* const X, const uword N, const uword norm_type = 0); + + template + inline static T direct_var(const std::complex* const X, const uword N, const uword norm_type = 0); + + + template + inline static typename get_pod_type::result direct_var(const subview_row& X, const uword norm_type = 0); + + template + inline static typename get_pod_type::result direct_var(const subview_col& X, const uword norm_type = 0); + + template + inline static typename get_pod_type::result direct_var(const diagview& X, const uword norm_type = 0); + + + template + inline static void apply(Mat& out, const mtOp& in); + + + template + inline static eT direct_var_robust(const eT* const X, const uword N, const uword norm_type = 0); + + template + inline static T direct_var_robust(const std::complex* const X, const uword N, const uword norm_type = 0); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/op_var_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/op_var_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,304 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup op_var +//! @{ + + +//! find the variance of an array +template +inline +eT +op_var::direct_var(const eT* const X, const uword n_elem, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(n_elem >= 2) + { + const eT acc1 = op_mean::direct_mean(X, n_elem); + + eT acc2 = eT(0); + eT acc3 = eT(0); + + uword i,j; + + for(i=0, j=1; j +inline +T +op_var::direct_var(const std::complex* const X, const uword n_elem, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(n_elem >= 2) + { + const eT acc1 = op_mean::direct_mean(X, n_elem); + + T acc2 = T(0); + eT acc3 = eT(0); + + for(uword i=0; i +inline +typename get_pod_type::result +op_var::direct_var(const subview_row& X, const uword norm_type) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.n_elem; + + podarray tmp(n_elem); + + eT* tmp_mem = tmp.memptr(); + + for(uword i=0; i +inline +typename get_pod_type::result +op_var::direct_var(const subview_col& X, const uword norm_type) + { + arma_extra_debug_sigprint(); + + return op_var::direct_var(X.colptr(0), X.n_elem, norm_type); + } + + + +//! find the variance of a diagview +template +inline +typename get_pod_type::result +op_var::direct_var(const diagview& X, const uword norm_type) + { + arma_extra_debug_sigprint(); + + const uword n_elem = X.n_elem; + + podarray tmp(n_elem); + + eT* tmp_mem = tmp.memptr(); + + for(uword i=0; i +inline +void +op_var::apply(Mat& out, const mtOp& in) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type in_eT; + typedef typename T1::pod_type out_eT; + + const unwrap_check_mixed tmp(in.m, out); + const Mat& X = tmp.M; + + const uword norm_type = in.aux_uword_a; + const uword dim = in.aux_uword_b; + + arma_debug_check( (norm_type > 1), "var(): incorrect usage. norm_type must be 0 or 1"); + arma_debug_check( (dim > 1), "var(): incorrect usage. dim must be 0 or 1" ); + + const uword X_n_rows = X.n_rows; + const uword X_n_cols = X.n_cols; + + if(dim == 0) + { + arma_extra_debug_print("op_var::apply(), dim = 0"); + + arma_debug_check( (X_n_rows == 0), "var(): given object has zero rows" ); + + out.set_size(1, X_n_cols); + + out_eT* out_mem = out.memptr(); + + for(uword col=0; col tmp(X_n_cols); + + in_eT* tmp_mem = tmp.memptr(); + out_eT* out_mem = out.memptr(); + + for(uword row=0; row +inline +eT +op_var::direct_var_robust(const eT* const X, const uword n_elem, const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(n_elem > 1) + { + eT r_mean = X[0]; + eT r_var = eT(0); + + for(uword i=1; i +inline +T +op_var::direct_var_robust(const std::complex* const X, const uword n_elem, const uword norm_type) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + if(n_elem > 1) + { + eT r_mean = X[0]; + T r_var = T(0); + + for(uword i=1; i +arma_inline +const eOpCube +operator/ + ( + const BaseCube& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! scalar / BaseCube +template +arma_inline +const eOpCube +operator/ + ( + const typename T1::elem_type k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! complex scalar / non-complex BaseCube (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_div_pre> +operator/ + ( + const std::complex& k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_div_pre>('j', X.get_ref(), k); + } + + + +//! non-complex BaseCube / complex scalar (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_div_post> +operator/ + ( + const BaseCube& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_div_post>('j', X.get_ref(), k); + } + + + +//! element-wise division of BaseCube objects with same element type +template +arma_inline +const eGlueCube +operator/ + ( + const BaseCube& X, + const BaseCube& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlueCube(X.get_ref(), Y.get_ref()); + } + + + +//! element-wise division of BaseCube objects with different element types +template +inline +const mtGlueCube::result, T1, T2, glue_mixed_div> +operator/ + ( + const BaseCube< typename force_different_type::T1_result, T1>& X, + const BaseCube< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_cube_minus.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_cube_minus.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,160 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_cube_minus +//! @{ + + + +//! unary - +template +arma_inline +const eOpCube +operator- + ( + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref()); + } + + + +//! cancellation of two consecutive negations: -(-T1) +template +arma_inline +const T1& +operator- + ( + const eOpCube& X + ) + { + arma_extra_debug_sigprint(); + + return X.m; + } + + + +//! BaseCube - scalar +template +arma_inline +const eOpCube +operator- + ( + const BaseCube& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! scalar - BaseCube +template +arma_inline +const eOpCube +operator- + ( + const typename T1::elem_type k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! complex scalar - non-complex BaseCube (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_minus_pre> +operator- + ( + const std::complex& k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_minus_pre>('j', X.get_ref(), k); + } + + + +//! non-complex BaseCube - complex scalar (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_minus_post> +operator- + ( + const BaseCube& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_minus_post>('j', X.get_ref(), k); + } + + + +//! subtraction of BaseCube objects with same element type +template +arma_inline +const eGlueCube +operator- + ( + const BaseCube& X, + const BaseCube& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlueCube(X.get_ref(), Y.get_ref()); + } + + + +//! subtraction of BaseCube objects with different element types +template +inline +const mtGlueCube::result, T1, T2, glue_mixed_minus> +operator- + ( + const BaseCube< typename force_different_type::T1_result, T1>& X, + const BaseCube< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_cube_plus.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_cube_plus.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,144 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_cube_plus +//! @{ + + + +//! unary plus operation (does nothing, but is required for completeness) +template +arma_inline +const BaseCube& +operator+ + ( + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return X; + } + + + +//! BaseCube + scalar +template +arma_inline +const eOpCube +operator+ + ( + const BaseCube& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! scalar + BaseCube +template +arma_inline +const eOpCube +operator+ + ( + const typename T1::elem_type k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! non-complex BaseCube + complex scalar (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_plus> +operator+ + ( + const BaseCube& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_plus>('j', X.get_ref(), k); + } + + + +//! complex scalar + non-complex BaseCube (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_plus> +operator+ + ( + const std::complex& k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_plus>('j', X.get_ref(), k); // NOTE: order is swapped + } + + + +//! addition of BaseCube objects with same element type +template +arma_inline +const eGlueCube +operator+ + ( + const BaseCube& X, + const BaseCube& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlueCube(X.get_ref(), Y.get_ref()); + } + + + +//! addition of BaseCube objects with different element types +template +inline +const mtGlueCube::result, T1, T2, glue_mixed_plus> +operator+ + ( + const BaseCube< typename force_different_type::T1_result, T1>& X, + const BaseCube< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_cube_relational.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_cube_relational.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,268 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_cube_relational +//! @{ + + + +// < : lt +// > : gt +// <= : lteq +// >= : gteq +// == : eq +// != : noteq + + + +template +inline +const mtGlueCube +operator< +(const BaseCube::result,T1>& X, const BaseCube::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlueCube +operator> +(const BaseCube::result,T1>& X, const BaseCube::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlueCube +operator<= +(const BaseCube::result,T1>& X, const BaseCube::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlueCube +operator>= +(const BaseCube::result,T1>& X, const BaseCube::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlueCube +operator== +(const BaseCube& X, const BaseCube& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlueCube +operator!= +(const BaseCube& X, const BaseCube& Y) + { + arma_extra_debug_sigprint(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +// +// +// + + + +template +inline +const mtOpCube +operator< +(const typename arma_not_cx::result val, const BaseCube::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator< +(const BaseCube::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator> +(const typename arma_not_cx::result val, const BaseCube::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator> +(const BaseCube::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator<= +(const typename arma_not_cx::result val, const BaseCube::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator<= +(const BaseCube::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator>= +(const typename arma_not_cx::result val, const BaseCube::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator>= +(const BaseCube::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator== +(const typename T1::elem_type val, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator== +(const BaseCube& X, const typename T1::elem_type val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator!= +(const typename T1::elem_type val, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +template +inline +const mtOpCube +operator!= +(const BaseCube& X, const typename T1::elem_type val) + { + arma_extra_debug_sigprint(); + + return mtOpCube(X.get_ref(), val); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_cube_schur.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_cube_schur.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,62 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_cube_schur +//! @{ + + +// operator %, which we define it to do a schur product (element-wise multiplication) + + +//! element-wise multiplication of BaseCube objects with same element type +template +arma_inline +const eGlueCube +operator% + ( + const BaseCube& X, + const BaseCube& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlueCube(X.get_ref(), Y.get_ref()); + } + + + +//! element-wise multiplication of BaseCube objects with different element types +template +inline +const mtGlueCube::result, T1, T2, glue_mixed_schur> +operator% + ( + const BaseCube< typename force_different_type::T1_result, T1>& X, + const BaseCube< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlueCube( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_cube_times.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_cube_times.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,89 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + + +//! \addtogroup operator_cube_times +//! @{ + + + +//! BaseCube * scalar +template +arma_inline +const eOpCube +operator* + ( + const BaseCube& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! scalar * BaseCube +template +arma_inline +const eOpCube +operator* + ( + const typename T1::elem_type k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return eOpCube(X.get_ref(), k); + } + + + +//! non-complex BaseCube * complex scalar (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_times> +operator* + ( + const BaseCube& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_times>('j', X.get_ref(), k); + } + + + +//! complex scalar * non-complex BaseCube (experimental) +template +arma_inline +const mtOpCube, T1, op_cx_scalar_times> +operator* + ( + const std::complex& k, + const BaseCube& X + ) + { + arma_extra_debug_sigprint(); + + return mtOpCube, T1, op_cx_scalar_times>('j', X.get_ref(), k); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_div.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_div.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,128 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_div +//! @{ + + + +//! Base / scalar +template +arma_inline +const eOp +operator/ + ( + const Base& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); + } + + + +//! scalar / Base +template +arma_inline +const eOp +operator/ + ( + const typename T1::elem_type k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); + } + + + +//! complex scalar / non-complex Base (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_div_pre> +operator/ + ( + const std::complex& k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_div_pre>('j', X.get_ref(), k); + } + + + +//! non-complex Base / complex scalar (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_div_post> +operator/ + ( + const Base& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_div_post>('j', X.get_ref(), k); + } + + + +//! element-wise division of Base objects with same element type +template +arma_inline +const eGlue +operator/ + ( + const Base& X, + const Base& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlue(X.get_ref(), Y.get_ref()); + } + + + +//! element-wise division of Base objects with different element types +template +inline +const mtGlue::result, T1, T2, glue_mixed_div> +operator/ + ( + const Base< typename force_different_type::T1_result, T1>& X, + const Base< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_minus.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_minus.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,156 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_minus +//! @{ + + + +//! unary - +template +arma_inline +const eOp +operator- +(const Base& X) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref()); + } + + + +//! cancellation of two consecutive negations: -(-T1) +template +arma_inline +const T1& +operator- +(const eOp& X) + { + arma_extra_debug_sigprint(); + + return X.m; + } + + + +//! Base - scalar +template +arma_inline +const eOp +operator- + ( + const Base& X, + const typename T1::elem_type k + ) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); + } + + + +//! scalar - Base +template +arma_inline +const eOp +operator- + ( + const typename T1::elem_type k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); + } + + + +//! complex scalar - non-complex Base (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_minus_pre> +operator- + ( + const std::complex& k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_minus_pre>('j', X.get_ref(), k); + } + + + +//! non-complex Base - complex scalar (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_minus_post> +operator- + ( + const Base& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_minus_post>('j', X.get_ref(), k); + } + + + +//! subtraction of Base objects with same element type +template +arma_inline +const eGlue +operator- + ( + const Base& X, + const Base& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlue(X.get_ref(), Y.get_ref()); + } + + + +//! subtraction of Base objects with different element types +template +inline +const mtGlue::result, T1, T2, glue_mixed_minus> +operator- + ( + const Base< typename force_different_type::T1_result, T1>& X, + const Base< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_ostream.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_ostream.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,81 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_ostream +//! @{ + + + +template +inline +std::ostream& +operator<< (std::ostream& o, const Base& X) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(X.get_ref()); + + arma_ostream::print(o, tmp.M, true); + + return o; + } + + + +template +inline +std::ostream& +operator<< (std::ostream& o, const BaseCube& X) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(X.get_ref()); + + arma_ostream::print(o, tmp.M, true); + + return o; + } + + + +//! Print the contents of a field to the specified stream. +template +inline +std::ostream& +operator<< (std::ostream& o, const field& X) + { + arma_extra_debug_sigprint(); + + arma_ostream::print(o, X); + + return o; + } + + + +//! Print the contents of a subfield to the specified stream +template +inline +std::ostream& +operator<< (std::ostream& o, const subview_field& X) + { + arma_extra_debug_sigprint(); + + arma_ostream::print(o, X); + + return o; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_plus.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_plus.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,136 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_plus +//! @{ + + + +//! unary plus operation (does nothing, but is required for completeness) +template +arma_inline +const Base& +operator+ +(const Base& X) + { + arma_extra_debug_sigprint(); + + return X; + } + + + +//! Base + scalar +template +arma_inline +const eOp +operator+ +(const Base& X, const typename T1::elem_type k) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); + } + + + +//! scalar + Base +template +arma_inline +const eOp +operator+ +(const typename T1::elem_type k, const Base& X) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(), k); // NOTE: order is swapped + } + + + +//! non-complex Base + complex scalar (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_plus> +operator+ + ( + const Base& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_plus>('j', X.get_ref(), k); + } + + + +//! complex scalar + non-complex Base (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_plus> +operator+ + ( + const std::complex& k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_plus>('j', X.get_ref(), k); // NOTE: order is swapped + } + + + +//! addition of Base objects with same element type +template +arma_inline +const eGlue +operator+ + ( + const Base& X, + const Base& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlue(X.get_ref(), Y.get_ref()); + } + + + +//! addition of Base objects with different element types +template +inline +const mtGlue::result, T1, T2, glue_mixed_plus> +operator+ + ( + const Base< typename force_different_type::T1_result, T1>& X, + const Base< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_relational.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_relational.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,267 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_relational +//! @{ + + +// < : lt +// > : gt +// <= : lteq +// >= : gteq +// == : eq +// != : noteq + + + +template +inline +const mtGlue +operator< +(const Base::result,T1>& X, const Base::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlue +operator> +(const Base::result,T1>& X, const Base::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlue +operator<= +(const Base::result,T1>& X, const Base::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlue +operator>= +(const Base::result,T1>& X, const Base::result,T2>& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlue +operator== +(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +template +inline +const mtGlue +operator!= +(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +// +// +// + + + +template +inline +const mtOp +operator< +(const typename arma_not_cx::result val, const Base::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator< +(const Base::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator> +(const typename arma_not_cx::result val, const Base::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator> +(const Base::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator<= +(const typename arma_not_cx::result val, const Base::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator<= +(const Base::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator>= +(const typename arma_not_cx::result val, const Base::result,T1>& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator>= +(const Base::result,T1>& X, const typename arma_not_cx::result val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator== +(const typename T1::elem_type val, const Base& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator== +(const Base& X, const typename T1::elem_type val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator!= +(const typename T1::elem_type val, const Base& X) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +template +inline +const mtOp +operator!= +(const Base& X, const typename T1::elem_type val) + { + arma_extra_debug_sigprint(); + + return mtOp(X.get_ref(), val); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_schur.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_schur.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,62 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup operator_schur +//! @{ + + +// operator %, which we define it to do a schur product (element-wise multiplication) + + +//! element-wise multiplication of Base objects with same element type +template +arma_inline +const eGlue +operator% + ( + const Base& X, + const Base& Y + ) + { + arma_extra_debug_sigprint(); + + return eGlue(X.get_ref(), Y.get_ref()); + } + + + +//! element-wise multiplication of Base objects with different element types +template +inline +const mtGlue::result, T1, T2, glue_mixed_schur> +operator% + ( + const Base< typename force_different_type::T1_result, T1>& X, + const Base< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/operator_times.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/operator_times.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,213 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +//! \addtogroup operator_times +//! @{ + + + +//! Base * scalar +template +arma_inline +const eOp +operator* +(const Base& X, const typename T1::elem_type k) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(),k); + } + + + +//! scalar * Base +template +arma_inline +const eOp +operator* +(const typename T1::elem_type k, const Base& X) + { + arma_extra_debug_sigprint(); + + return eOp(X.get_ref(),k); // NOTE: order is swapped + } + + + +//! non-complex Base * complex scalar (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_times> +operator* + ( + const Base& X, + const std::complex& k + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_times>('j', X.get_ref(), k); + } + + + +//! complex scalar * non-complex Base (experimental) +template +arma_inline +const mtOp, T1, op_cx_scalar_times> +operator* + ( + const std::complex& k, + const Base& X + ) + { + arma_extra_debug_sigprint(); + + return mtOp, T1, op_cx_scalar_times>('j', X.get_ref(), k); + } + + + +//! scalar * trans(T1) +template +arma_inline +const Op +operator* +(const typename T1::elem_type k, const Op& X) + { + arma_extra_debug_sigprint(); + + return Op(X.m, k); + } + + + +//! trans(T1) * scalar +template +arma_inline +const Op +operator* +(const Op& X, const typename T1::elem_type k) + { + arma_extra_debug_sigprint(); + + return Op(X.m, k); + } + + + +//! Base * diagmat +template +arma_inline +const Glue, glue_times_diag> +operator* +(const Base& X, const Op& Y) + { + arma_extra_debug_sigprint(); + + return Glue, glue_times_diag>(X.get_ref(), Y); + } + + + +//! diagmat * Base +template +arma_inline +const Glue, T2, glue_times_diag> +operator* +(const Op& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return Glue, T2, glue_times_diag>(X, Y.get_ref()); + } + + + +//! diagmat * diagmat +template +arma_inline +Mat< typename promote_type::result > +operator* +(const Op& X, const Op& Y) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + const diagmat_proxy A(X.m); + const diagmat_proxy B(Y.m); + + arma_debug_assert_mul_size(A.n_elem, A.n_elem, B.n_elem, B.n_elem, "matrix multiply"); + + const uword N = A.n_elem; + + Mat out(N,N); + + out.zeros(); + + for(uword i=0; i::apply( A[i] ) * upgrade_val::apply( B[i] ); + } + + return out; + } + + + +//! multiplication of Base objects with same element type +template +arma_inline +const Glue +operator* +(const Base& X, const Base& Y) + { + arma_extra_debug_sigprint(); + + return Glue(X.get_ref(), Y.get_ref()); + } + + + +//! multiplication of Base objects with different element types +template +inline +const mtGlue< typename promote_type::result, T1, T2, glue_mixed_times > +operator* + ( + const Base< typename force_different_type::T1_result, T1>& X, + const Base< typename force_different_type::T2_result, T2>& Y + ) + { + arma_extra_debug_sigprint(); + + typedef typename T1::elem_type eT1; + typedef typename T2::elem_type eT2; + + typedef typename promote_type::result out_eT; + + promote_type::check(); + + return mtGlue( X.get_ref(), Y.get_ref() ); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/podarray_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/podarray_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,81 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup podarray +//! @{ + + + +struct podarray_prealloc_n_elem + { + static const uword val = 16; + }; + + + +//! A lightweight array for POD types. If the amount of memory requested is small, the stack is used. + +template +class podarray + { + public: + + arma_aligned const uword n_elem; //!< number of elements held + arma_aligned const eT* const mem; //!< pointer to memory used by the object + + + protected: + //! Internal memory, to avoid calling the 'new' operator for small amounts of memory. + arma_aligned eT mem_local[ podarray_prealloc_n_elem::val ]; + + + public: + + inline ~podarray(); + inline podarray(); + + inline podarray (const podarray& x); + inline const podarray& operator=(const podarray& x); + + arma_inline explicit podarray(const uword new_N); + + arma_inline explicit podarray(const eT* X, const uword new_N); + + arma_inline eT& operator[] (const uword i); + arma_inline eT operator[] (const uword i) const; + + arma_inline eT& operator() (const uword i); + arma_inline eT operator() (const uword i) const; + + inline void set_size(const uword new_n_elem); + inline void reset(); + + inline void fill(const eT val); + + inline void zeros(); + inline void zeros(const uword new_n_elem); + + arma_inline eT* memptr(); + arma_inline const eT* memptr() const; + + arma_hot inline void copy_row(const Mat& A, const uword row); + + protected: + + inline void init(const uword new_n_elem); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/podarray_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/podarray_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,323 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup podarray +//! @{ + + +template +inline +podarray::~podarray() + { + arma_extra_debug_sigprint_this(this); + + if(n_elem > sizeof(mem_local)/sizeof(eT) ) + { + delete [] mem; + } + + if(arma_config::debug == true) + { + access::rw(n_elem) = 0; + access::rw(mem) = 0; + } + } + + + +template +inline +podarray::podarray() + : n_elem(0) + , mem (0) + { + arma_extra_debug_sigprint_this(this); + } + + + +template +inline +podarray::podarray(const podarray& x) + : n_elem(0) + , mem (0) + { + arma_extra_debug_sigprint(); + + this->operator=(x); + } + + + +template +inline +const podarray& +podarray::operator=(const podarray& x) + { + arma_extra_debug_sigprint(); + + if(this != &x) + { + init(x.n_elem); + + arrayops::copy( memptr(), x.memptr(), n_elem ); + } + + return *this; + } + + + +template +arma_inline +podarray::podarray(const uword new_n_elem) + : n_elem(0) + , mem (0) + { + arma_extra_debug_sigprint_this(this); + + init(new_n_elem); + } + + + +template +arma_inline +podarray::podarray(const eT* X, const uword new_n_elem) + : n_elem(0) + , mem (0) + { + arma_extra_debug_sigprint_this(this); + + init(new_n_elem); + + arrayops::copy( memptr(), X, new_n_elem ); + } + + + +template +arma_inline +eT +podarray::operator[] (const uword i) const + { + return mem[i]; + } + + + +template +arma_inline +eT& +podarray::operator[] (const uword i) + { + return access::rw(mem[i]); + } + + + +template +arma_inline +eT +podarray::operator() (const uword i) const + { + arma_debug_check( (i >= n_elem), "podarray::operator(): index out of bounds"); + return mem[i]; + } + + + +template +arma_inline +eT& +podarray::operator() (const uword i) + { + arma_debug_check( (i >= n_elem), "podarray::operator(): index out of bounds"); + return access::rw(mem[i]); + } + + + +template +inline +void +podarray::set_size(const uword new_n_elem) + { + arma_extra_debug_sigprint(); + + init(new_n_elem); + } + + + +template +inline +void +podarray::reset() + { + arma_extra_debug_sigprint(); + + init(0); + } + + + +template +inline +void +podarray::fill(const eT val) + { + arma_extra_debug_sigprint(); + + arrayops::inplace_set(memptr(), val, n_elem); + } + + + +template +inline +void +podarray::zeros() + { + arma_extra_debug_sigprint(); + + fill(eT(0)); + } + + + +template +inline +void +podarray::zeros(const uword new_n_elem) + { + arma_extra_debug_sigprint(); + + init(new_n_elem); + fill(eT(0)); + } + + + +template +arma_inline +eT* +podarray::memptr() + { + return const_cast(mem); + } + + + +template +arma_inline +const eT* +podarray::memptr() const + { + return mem; + } + + + +template +arma_hot +inline +void +podarray::copy_row(const Mat& A, const uword row) + { + const uword cols = A.n_cols; + + // note: this function assumes that the podarray has been set to the correct size beforehand + eT* out = memptr(); + + switch(cols) + { + default: + { + uword i,j; + for(i=0, j=1; j < cols; i+=2, j+=2) + { + const eT tmp_i = A.at(row, i); + const eT tmp_j = A.at(row, j); + + out[i] = tmp_i; + out[j] = tmp_j; + } + + if(i < cols) + { + out[i] = A.at(row, i); + } + } + break; + + case 8: + out[7] = A.at(row, 7); + + case 7: + out[6] = A.at(row, 6); + + case 6: + out[5] = A.at(row, 5); + + case 5: + out[4] = A.at(row, 4); + + case 4: + out[3] = A.at(row, 3); + + case 3: + out[2] = A.at(row, 2); + + case 2: + out[1] = A.at(row, 1); + + case 1: + out[0] = A.at(row, 0); + } + } + + + +template +inline +void +podarray::init(const uword new_n_elem) + { + arma_extra_debug_sigprint(); + + if(n_elem == new_n_elem) + { + return; + } + + if(n_elem > sizeof(mem_local)/sizeof(eT) ) + { + delete [] mem; + } + + if(new_n_elem <= sizeof(mem_local)/sizeof(eT) ) + { + access::rw(mem) = mem_local; + } + else + { + access::rw(mem) = new eT[new_n_elem]; + } + + access::rw(n_elem) = new_n_elem; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/promote_type.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/promote_type.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,217 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup promote_type +//! @{ + + +template +struct is_promotable + { + static const bool value = false; + typedef T1 result; + }; + + +struct is_promotable_ok + { + static const bool value = true; + }; + + +template struct is_promotable : public is_promotable_ok { typedef T result; }; +template struct is_promotable, T> : public is_promotable_ok { typedef std::complex result; }; + +template<> struct is_promotable, std::complex > : public is_promotable_ok { typedef std::complex result; }; +template<> struct is_promotable, float> : public is_promotable_ok { typedef std::complex result; }; +template<> struct is_promotable, double> : public is_promotable_ok { typedef std::complex result; }; + +#if defined(ARMA_64BIT_WORD) +template struct is_promotable, u64> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, s64> : public is_promotable_ok { typedef std::complex result; }; +#endif +template struct is_promotable, s32> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, u32> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, s16> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, u16> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, s8> : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable, u8> : public is_promotable_ok { typedef std::complex result; }; + + +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +#endif +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +#endif +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +#endif + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +#endif + +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef u32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef u32 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; // s32 ? +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; // s32 ? +template<> struct is_promotable : public is_promotable_ok { typedef u16 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s8 result; }; // s16 ? + + + + +// +// mirrored versions + +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; + +template<> struct is_promotable, std::complex > : public is_promotable_ok { typedef std::complex result; }; +template<> struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template<> struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; + +#if defined(ARMA_64BIT_WORD) +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +#endif +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; +template struct is_promotable > : public is_promotable_ok { typedef std::complex result; }; + + +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +#endif +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; +template<> struct is_promotable : public is_promotable_ok { typedef double result; }; + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +#endif +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; +template<> struct is_promotable : public is_promotable_ok { typedef float result; }; + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef u64 result; }; +#endif + +#if defined(ARMA_64BIT_WORD) +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s64 result; }; +#endif + +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef u32 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s32 result; }; // float ? +template<> struct is_promotable : public is_promotable_ok { typedef u32 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; // s32 ? +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s16 result; }; // s32 ? +template<> struct is_promotable : public is_promotable_ok { typedef u16 result; }; + +template<> struct is_promotable : public is_promotable_ok { typedef s8 result; }; // s16 ? + + + + + +template +struct promote_type + { + inline static void check() + { + arma_type_check(( is_promotable::value == false )); + } + + typedef typename is_promotable::result result; + }; + + + +template +struct eT_promoter + { + typedef typename promote_type::result eT; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/restrictors.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/restrictors.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,188 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup restrictors +//! @{ + + + +// structures for template based restrictions of input/output arguments +// (part of the SFINAE approach) +// http://en.wikipedia.org/wiki/SFINAE + + +template struct arma_scalar_only { }; + +template<> struct arma_scalar_only { typedef u8 result; }; +template<> struct arma_scalar_only { typedef s8 result; }; +template<> struct arma_scalar_only { typedef u16 result; }; +template<> struct arma_scalar_only { typedef s16 result; }; +template<> struct arma_scalar_only { typedef u32 result; }; +template<> struct arma_scalar_only { typedef s32 result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct arma_scalar_only { typedef u64 result; }; +template<> struct arma_scalar_only { typedef s64 result; }; +#endif +template<> struct arma_scalar_only { typedef float result; }; +template<> struct arma_scalar_only { typedef double result; }; + + +template +struct arma_scalar_only< std::complex > { typedef std::complex result; }; + + + +template struct arma_integral_only { }; + +template<> struct arma_integral_only { typedef u8 result; }; +template<> struct arma_integral_only { typedef s8 result; }; +template<> struct arma_integral_only { typedef u16 result; }; +template<> struct arma_integral_only { typedef s16 result; }; +template<> struct arma_integral_only { typedef u32 result; }; +template<> struct arma_integral_only { typedef s32 result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct arma_integral_only { typedef u64 result; }; +template<> struct arma_integral_only { typedef s64 result; }; +#endif + + + +template struct arma_unsigned_integral_only { }; + +template<> struct arma_unsigned_integral_only { typedef u8 result; }; +template<> struct arma_unsigned_integral_only { typedef u16 result; }; +template<> struct arma_unsigned_integral_only { typedef u32 result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct arma_unsigned_integral_only { typedef u64 result; }; +#endif + + + +template struct arma_signed_integral_only { }; + +template<> struct arma_signed_integral_only { typedef s8 result; }; +template<> struct arma_signed_integral_only { typedef s16 result; }; +template<> struct arma_signed_integral_only { typedef s32 result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct arma_signed_integral_only { typedef s64 result; }; +#endif + + + +template struct arma_signed_only { }; + +template<> struct arma_signed_only { typedef s8 result; }; +template<> struct arma_signed_only { typedef s16 result; }; +template<> struct arma_signed_only { typedef s32 result; }; +#if defined(ARMA_64BIT_WORD) +template<> struct arma_signed_only { typedef s64 result; }; +#endif +template<> struct arma_signed_only { typedef float result; }; +template<> struct arma_signed_only { typedef double result; }; + +template struct arma_signed_only< std::complex > { typedef std::complex result; }; + + + +template struct arma_float_only { }; + +template<> struct arma_float_only { typedef float result; }; +template<> struct arma_float_only { typedef double result; }; + + + +template struct arma_float_or_cx_only { }; + +template<> struct arma_float_or_cx_only< float > { typedef float result; }; +template<> struct arma_float_or_cx_only< double > { typedef double result; }; +template<> struct arma_float_or_cx_only< std::complex > { typedef std::complex result; }; +template<> struct arma_float_or_cx_only< std::complex > { typedef std::complex result; }; + + + +template struct arma_cx_only { }; + +template<> struct arma_cx_only< std::complex > { typedef std::complex result; }; +template<> struct arma_cx_only< std::complex > { typedef std::complex result; }; + + + +template struct arma_not_cx { typedef T result; }; +template struct arma_not_cx< std::complex > { }; + + + +template struct arma_blas_type_only { }; + +template<> struct arma_blas_type_only< float > { typedef float result; }; +template<> struct arma_blas_type_only< double > { typedef double result; }; +template<> struct arma_blas_type_only< std::complex > { typedef std::complex result; }; +template<> struct arma_blas_type_only< std::complex > { typedef std::complex result; }; + + + +template struct arma_op_rel_only { }; + +template<> struct arma_op_rel_only< op_rel_lt_pre > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_lt_post > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_gt_pre > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_gt_post > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_lteq_pre > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_lteq_post > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_gteq_pre > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_gteq_post > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_eq > { typedef int result; }; +template<> struct arma_op_rel_only< op_rel_noteq > { typedef int result; }; + + + +template struct arma_not_op_rel { typedef int result; }; + +template<> struct arma_not_op_rel< op_rel_lt_pre > { }; +template<> struct arma_not_op_rel< op_rel_lt_post > { }; +template<> struct arma_not_op_rel< op_rel_gt_pre > { }; +template<> struct arma_not_op_rel< op_rel_gt_post > { }; +template<> struct arma_not_op_rel< op_rel_lteq_pre > { }; +template<> struct arma_not_op_rel< op_rel_lteq_post > { }; +template<> struct arma_not_op_rel< op_rel_gteq_pre > { }; +template<> struct arma_not_op_rel< op_rel_gteq_post > { }; +template<> struct arma_not_op_rel< op_rel_eq > { }; +template<> struct arma_not_op_rel< op_rel_noteq > { }; + + + +template struct arma_glue_rel_only { }; + +template<> struct arma_glue_rel_only< glue_rel_lt > { typedef int result; }; +template<> struct arma_glue_rel_only< glue_rel_gt > { typedef int result; }; +template<> struct arma_glue_rel_only< glue_rel_lteq > { typedef int result; }; +template<> struct arma_glue_rel_only< glue_rel_gteq > { typedef int result; }; +template<> struct arma_glue_rel_only< glue_rel_eq > { typedef int result; }; +template<> struct arma_glue_rel_only< glue_rel_noteq > { typedef int result; }; + + + +template struct arma_Mat_Col_Row_only { }; + +template struct arma_Mat_Col_Row_only< Mat > { typedef Mat result; }; +template struct arma_Mat_Col_Row_only< Col > { typedef Col result; }; +template struct arma_Mat_Col_Row_only< Row > { typedef Row result; }; + + + +template struct arma_Cube_only { }; +template struct arma_Cube_only< Cube > { typedef Cube result; }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/running_stat_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/running_stat_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,113 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup running_stat +//! @{ + + + +template +class arma_counter + { + public: + + inline ~arma_counter(); + inline arma_counter(); + + inline const arma_counter& operator++(); + inline void operator++(int); + + inline void reset(); + inline eT value() const; + inline eT value_plus_1() const; + inline eT value_minus_1() const; + + + private: + + arma_aligned eT d_count; + arma_aligned uword i_count; + }; + + + +//! Class for keeping statistics of a continuously sampled process / signal. +//! Useful if the storage of individual samples is not necessary or desired. +//! Also useful if the number of samples is not known beforehand or exceeds +//! available memory. +template +class running_stat + { + public: + + typedef typename get_pod_type::result T; + + + inline ~running_stat(); + inline running_stat(); + + inline void operator() (const T sample); + inline void operator() (const std::complex& sample); + + inline void reset(); + + inline eT mean() const; + + inline T var (const uword norm_type = 0) const; + inline T stddev(const uword norm_type = 0) const; + + inline eT min() const; + inline eT max() const; + + inline T count() const; + + // + // + + private: + + arma_aligned arma_counter counter; + + arma_aligned eT r_mean; + arma_aligned T r_var; + + arma_aligned eT min_val; + arma_aligned eT max_val; + + arma_aligned T min_val_norm; + arma_aligned T max_val_norm; + + + friend class running_stat_aux; + }; + + + +class running_stat_aux + { + public: + + template + inline static void update_stats(running_stat& x, const eT sample); + + template + inline static void update_stats(running_stat< std::complex >& x, const T sample); + + template + inline static void update_stats(running_stat< std::complex >& x, const std::complex& sample); + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/running_stat_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/running_stat_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,427 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup running_stat +//! @{ + + + +template +inline +arma_counter::~arma_counter() + { + arma_extra_debug_sigprint_this(this); + } + + + +template +inline +arma_counter::arma_counter() + : d_count( eT(0)) + , i_count(uword(0)) + { + arma_extra_debug_sigprint_this(this); + } + + + +template +inline +const arma_counter& +arma_counter::operator++() + { + if(i_count < ARMA_MAX_UWORD) + { + i_count++; + } + else + { + d_count += eT(ARMA_MAX_UWORD); + i_count = 0; + } + + return *this; + } + + + +template +inline +void +arma_counter::operator++(int) + { + operator++(); + } + + + +template +inline +void +arma_counter::reset() + { + d_count = eT(0); + i_count = uword(0); + } + + + +template +inline +eT +arma_counter::value() const + { + return d_count + eT(i_count); + } + + + +template +inline +eT +arma_counter::value_plus_1() const + { + if(i_count < ARMA_MAX_UWORD) + { + return d_count + eT(i_count + 1); + } + else + { + return d_count + eT(ARMA_MAX_UWORD) + eT(1); + } + } + + + +template +inline +eT +arma_counter::value_minus_1() const + { + if(i_count > 0) + { + return d_count + eT(i_count - 1); + } + else + { + return d_count - eT(1); + } + } + + + +// + + + +template +running_stat::~running_stat() + { + arma_extra_debug_sigprint_this(this); + } + + + +template +running_stat::running_stat() + : r_mean ( eT(0)) + , r_var (typename running_stat::T(0)) + , min_val ( eT(0)) + , max_val ( eT(0)) + , min_val_norm(typename running_stat::T(0)) + , max_val_norm(typename running_stat::T(0)) + { + arma_extra_debug_sigprint_this(this); + } + + + +//! update statistics to reflect new sample +template +inline +void +running_stat::operator() (const typename running_stat::T sample) + { + arma_extra_debug_sigprint(); + + if( arma_isfinite(sample) == false ) + { + arma_warn(true, "running_stat: sample ignored as it is non-finite" ); + return; + } + + running_stat_aux::update_stats(*this, sample); + } + + + +//! update statistics to reflect new sample (version for complex numbers) +template +inline +void +running_stat::operator() (const std::complex< typename running_stat::T >& sample) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_same_type::T > >::value == false )); + + if( arma_isfinite(sample) == false ) + { + arma_warn(true, "running_stat: sample ignored as it is non-finite" ); + return; + } + + running_stat_aux::update_stats(*this, sample); + } + + + +//! set all statistics to zero +template +inline +void +running_stat::reset() + { + arma_extra_debug_sigprint(); + + typedef typename running_stat::T T; + + counter.reset(); + + r_mean = eT(0); + r_var = T(0); + + min_val = eT(0); + max_val = eT(0); + + min_val_norm = T(0); + max_val_norm = T(0); + } + + + +//! mean or average value +template +inline +eT +running_stat::mean() const + { + arma_extra_debug_sigprint(); + + return r_mean; + } + + + +//! variance +template +inline +typename running_stat::T +running_stat::var(const uword norm_type) const + { + arma_extra_debug_sigprint(); + + const T N = counter.value(); + + if(N > T(1)) + { + if(norm_type == 0) + { + return r_var; + } + else + { + const T N_minus_1 = counter.value_minus_1(); + return (N_minus_1/N) * r_var; + } + } + else + { + return T(0); + } + } + + + +//! standard deviation +template +inline +typename running_stat::T +running_stat::stddev(const uword norm_type) const + { + arma_extra_debug_sigprint(); + + return std::sqrt( (*this).var(norm_type) ); + } + + + +//! minimum value +template +inline +eT +running_stat::min() const + { + arma_extra_debug_sigprint(); + + return min_val; + } + + + +//! maximum value +template +inline +eT +running_stat::max() const + { + arma_extra_debug_sigprint(); + + return max_val; + } + + + +//! number of samples so far +template +inline +typename get_pod_type::result +running_stat::count() const + { + arma_extra_debug_sigprint(); + + return counter.value(); + } + + + +//! update statistics to reflect new sample +template +inline +void +running_stat_aux::update_stats(running_stat& x, const eT sample) + { + arma_extra_debug_sigprint(); + + typedef typename running_stat::T T; + + const T N = x.counter.value(); + + if(N > T(0)) + { + if(sample < x.min_val) + { + x.min_val = sample; + } + + if(sample > x.max_val) + { + x.max_val = sample; + } + + const T N_plus_1 = x.counter.value_plus_1(); + const T N_minus_1 = x.counter.value_minus_1(); + + // note: variance has to be updated before the mean + + const eT tmp = sample - x.r_mean; + + x.r_var = N_minus_1/N * x.r_var + (tmp*tmp)/N_plus_1; + + x.r_mean = x.r_mean + (sample - x.r_mean)/N_plus_1; + //x.r_mean = (N/N_plus_1)*x.r_mean + sample/N_plus_1; + //x.r_mean = (x.r_mean + sample/N) * N/N_plus_1; + } + else + { + x.r_mean = sample; + x.min_val = sample; + x.max_val = sample; + + // r_var is initialised to zero + // in the constructor and reset() + } + + x.counter++; + } + + + +//! update statistics to reflect new sample (version for complex numbers) +template +inline +void +running_stat_aux::update_stats(running_stat< std::complex >& x, const T sample) + { + arma_extra_debug_sigprint(); + + running_stat_aux::update_stats(x, std::complex(sample)); + } + + + +//! alter statistics to reflect new sample (version for complex numbers) +template +inline +void +running_stat_aux::update_stats(running_stat< std::complex >& x, const std::complex& sample) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + const T sample_norm = std::norm(sample); + const T N = x.counter.value(); + + if(N > T(0)) + { + if(sample_norm < x.min_val_norm) + { + x.min_val_norm = sample_norm; + x.min_val = sample; + } + + if(sample_norm > x.max_val_norm) + { + x.max_val_norm = sample_norm; + x.max_val = sample; + } + + const T N_plus_1 = x.counter.value_plus_1(); + const T N_minus_1 = x.counter.value_minus_1(); + + x.r_var = N_minus_1/N * x.r_var + std::norm(sample - x.r_mean)/N_plus_1; + + x.r_mean = x.r_mean + (sample - x.r_mean)/N_plus_1; + //x.r_mean = (N/N_plus_1)*x.r_mean + sample/N_plus_1; + //x.r_mean = (x.r_mean + sample/N) * N/N_plus_1; + } + else + { + x.r_mean = sample; + x.min_val = sample; + x.max_val = sample; + x.min_val_norm = sample_norm; + x.max_val_norm = sample_norm; + + // r_var is initialised to zero + // in the constructor and reset() + } + + x.counter++; + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/running_stat_vec_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/running_stat_vec_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,115 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup running_stat_vec +//! @{ + + + +//! Class for keeping statistics of a continuously sampled process / signal. +//! Useful if the storage of individual samples is not necessary or desired. +//! Also useful if the number of samples is not known beforehand or exceeds +//! available memory. +template +class running_stat_vec + { + public: + + typedef typename get_pod_type::result T; + + inline ~running_stat_vec(); + inline running_stat_vec(const bool in_calc_cov = false); + + inline running_stat_vec(const running_stat_vec& in_rsv); + + inline const running_stat_vec& operator=(const running_stat_vec& in_rsv); + + template arma_hot inline void operator() (const Base< T, T1>& X); + template arma_hot inline void operator() (const Base< std::complex, T1>& X); + + inline void reset(); + + inline const Mat& mean() const; + + inline const Mat< T>& var (const uword norm_type = 0); + inline Mat< T> stddev(const uword norm_type = 0) const; + inline const Mat& cov (const uword norm_type = 0); + + inline const Mat& min() const; + inline const Mat& max() const; + + inline T count() const; + + // + // + + private: + + const bool calc_cov; + + arma_aligned arma_counter counter; + + arma_aligned Mat r_mean; + arma_aligned Mat< T> r_var; + arma_aligned Mat r_cov; + + arma_aligned Mat min_val; + arma_aligned Mat max_val; + + arma_aligned Mat< T> min_val_norm; + arma_aligned Mat< T> max_val_norm; + + arma_aligned Mat< T> r_var_dummy; + arma_aligned Mat r_cov_dummy; + + arma_aligned Mat tmp1; + arma_aligned Mat tmp2; + + friend class running_stat_vec_aux; + }; + + + +class running_stat_vec_aux + { + public: + + template + inline static void update_stats(running_stat_vec< eT >& x, const Mat& sample); + + template + inline static void update_stats(running_stat_vec< std::complex >& x, const Mat< T>& sample); + + template + inline static void update_stats(running_stat_vec< std::complex >& x, const Mat< std::complex >& sample); + + // + + template + inline static Mat var(const running_stat_vec< eT >& x, const uword norm_type = 0); + + template + inline static Mat< T> var(const running_stat_vec< std::complex >& x, const uword norm_type = 0); + + // + + template + inline static Mat< eT > cov(const running_stat_vec< eT >& x, const uword norm_type = 0); + + template + inline static Mat< std::complex > cov(const running_stat_vec< std::complex >& x, const uword norm_type = 0); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/running_stat_vec_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/running_stat_vec_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,578 @@ +// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup running_stat_vec +//! @{ + + + +template +running_stat_vec::~running_stat_vec() + { + arma_extra_debug_sigprint_this(this); + } + + + +template +running_stat_vec::running_stat_vec(const bool in_calc_cov) + : calc_cov(in_calc_cov) + { + arma_extra_debug_sigprint_this(this); + } + + + +template +running_stat_vec::running_stat_vec(const running_stat_vec& in_rsv) + : calc_cov (in_rsv.calc_cov) + , counter (in_rsv.counter) + , r_mean (in_rsv.r_mean) + , r_var (in_rsv.r_var) + , r_cov (in_rsv.r_cov) + , min_val (in_rsv.min_val) + , max_val (in_rsv.max_val) + , min_val_norm(in_rsv.min_val_norm) + , max_val_norm(in_rsv.max_val_norm) + { + arma_extra_debug_sigprint_this(this); + } + + + +template +const running_stat_vec& +running_stat_vec::operator=(const running_stat_vec& in_rsv) + { + arma_extra_debug_sigprint(); + + access::rw(calc_cov) = in_rsv.calc_cov; + + counter = in_rsv.counter; + r_mean = in_rsv.r_mean; + r_var = in_rsv.r_var; + r_cov = in_rsv.r_cov; + min_val = in_rsv.min_val; + max_val = in_rsv.max_val; + min_val_norm = in_rsv.min_val_norm; + max_val_norm = in_rsv.max_val_norm; + + return *this; + } + + + +//! update statistics to reflect new sample +template +template +arma_hot +inline +void +running_stat_vec::operator() (const Base::result, T1>& X) + { + arma_extra_debug_sigprint(); + + //typedef typename get_pod_type::result T; + + const unwrap tmp(X.get_ref()); + const Mat& sample = tmp.M; + + if( sample.is_empty() ) + { + return; + } + + if( sample.is_finite() == false ) + { + arma_warn(true, "running_stat_vec: sample ignored as it has non-finite elements"); + return; + } + + running_stat_vec_aux::update_stats(*this, sample); + } + + + +//! update statistics to reflect new sample (version for complex numbers) +template +template +arma_hot +inline +void +running_stat_vec::operator() (const Base::result>, T1>& X) + { + arma_extra_debug_sigprint(); + + //typedef typename std::complex::result> eT; + + const unwrap tmp(X.get_ref()); + const Mat& sample = tmp.M; + + if( sample.is_empty() ) + { + return; + } + + if( sample.is_finite() == false ) + { + arma_warn(true, "running_stat_vec: sample ignored as it has non-finite elements"); + return; + } + + running_stat_vec_aux::update_stats(*this, sample); + } + + + +//! set all statistics to zero +template +inline +void +running_stat_vec::reset() + { + arma_extra_debug_sigprint(); + + counter.reset(); + + r_mean.reset(); + r_var.reset(); + r_cov.reset(); + + min_val.reset(); + max_val.reset(); + + min_val_norm.reset(); + max_val_norm.reset(); + + r_var_dummy.reset(); + r_cov_dummy.reset(); + + tmp1.reset(); + tmp2.reset(); + } + + + +//! mean or average value +template +inline +const Mat& +running_stat_vec::mean() const + { + arma_extra_debug_sigprint(); + + return r_mean; + } + + + +//! variance +template +inline +const Mat::result>& +running_stat_vec::var(const uword norm_type) + { + arma_extra_debug_sigprint(); + + const T N = counter.value(); + + if(N > T(1)) + { + if(norm_type == 0) + { + return r_var; + } + else + { + const T N_minus_1 = counter.value_minus_1(); + + r_var_dummy = (N_minus_1/N) * r_var; + + return r_var_dummy; + } + } + else + { + r_var_dummy.zeros(r_mean.n_rows, r_mean.n_cols); + + return r_var_dummy; + } + + } + + + +//! standard deviation +template +inline +Mat::result> +running_stat_vec::stddev(const uword norm_type) const + { + arma_extra_debug_sigprint(); + + const T N = counter.value(); + + if(N > T(1)) + { + if(norm_type == 0) + { + return sqrt(r_var); + } + else + { + const T N_minus_1 = counter.value_minus_1(); + + return sqrt( (N_minus_1/N) * r_var ); + } + } + else + { + return Mat(); + } + } + + + +//! covariance +template +inline +const Mat& +running_stat_vec::cov(const uword norm_type) + { + arma_extra_debug_sigprint(); + + if(calc_cov == true) + { + const T N = counter.value(); + + if(N > T(1)) + { + if(norm_type == 0) + { + return r_cov; + } + else + { + const T N_minus_1 = counter.value_minus_1(); + + r_cov_dummy = (N_minus_1/N) * r_cov; + + return r_cov_dummy; + } + } + else + { + r_cov_dummy.zeros(r_mean.n_rows, r_mean.n_cols); + + return r_cov_dummy; + } + } + else + { + r_cov_dummy.reset(); + + return r_cov_dummy; + } + + } + + + +//! vector with minimum values +template +inline +const Mat& +running_stat_vec::min() const + { + arma_extra_debug_sigprint(); + + return min_val; + } + + + +//! vector with maximum values +template +inline +const Mat& +running_stat_vec::max() const + { + arma_extra_debug_sigprint(); + + return max_val; + } + + + +//! number of samples so far +template +inline +typename get_pod_type::result +running_stat_vec::count() const + { + arma_extra_debug_sigprint(); + + return counter.value(); + } + + + +// + + + +//! update statistics to reflect new sample +template +inline +void +running_stat_vec_aux::update_stats(running_stat_vec& x, const Mat& sample) + { + arma_extra_debug_sigprint(); + + typedef typename running_stat_vec::T T; + + const T N = x.counter.value(); + + if(N > T(0)) + { + arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch"); + + const uword n_elem = sample.n_elem; + const eT* sample_mem = sample.memptr(); + eT* r_mean_mem = x.r_mean.memptr(); + T* r_var_mem = x.r_var.memptr(); + eT* min_val_mem = x.min_val.memptr(); + eT* max_val_mem = x.max_val.memptr(); + + const T N_plus_1 = x.counter.value_plus_1(); + const T N_minus_1 = x.counter.value_minus_1(); + + if(x.calc_cov == true) + { + Mat& tmp1 = x.tmp1; + Mat& tmp2 = x.tmp2; + + tmp1 = sample - x.r_mean; + + if(sample.n_cols == 1) + { + tmp2 = tmp1*trans(tmp1); + } + else + { + tmp2 = trans(tmp1)*tmp1; + } + + x.r_cov *= (N_minus_1/N); + x.r_cov += tmp2 / N_plus_1; + } + + + for(uword i=0; i max_val_mem[i]) + { + max_val_mem[i] = val; + } + + const eT r_mean_val = r_mean_mem[i]; + const eT tmp = val - r_mean_val; + + r_var_mem[i] = N_minus_1/N * r_var_mem[i] + (tmp*tmp)/N_plus_1; + + r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1; + } + } + else + { + arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector"); + + x.r_mean.set_size(sample.n_rows, sample.n_cols); + + x.r_var.zeros(sample.n_rows, sample.n_cols); + + if(x.calc_cov == true) + { + x.r_cov.zeros(sample.n_elem, sample.n_elem); + } + + x.min_val.set_size(sample.n_rows, sample.n_cols); + x.max_val.set_size(sample.n_rows, sample.n_cols); + + + const uword n_elem = sample.n_elem; + const eT* sample_mem = sample.memptr(); + eT* r_mean_mem = x.r_mean.memptr(); + eT* min_val_mem = x.min_val.memptr(); + eT* max_val_mem = x.max_val.memptr(); + + + for(uword i=0; i +inline +void +running_stat_vec_aux::update_stats(running_stat_vec< std::complex >& x, const Mat& sample) + { + arma_extra_debug_sigprint(); + + const Mat< std::complex > tmp = conv_to< Mat< std::complex > >::from(sample); + + running_stat_vec_aux::update_stats(x, tmp); + } + + + +//! alter statistics to reflect new sample (version for complex numbers) +template +inline +void +running_stat_vec_aux::update_stats(running_stat_vec< std::complex >& x, const Mat< std::complex >& sample) + { + arma_extra_debug_sigprint(); + + typedef typename std::complex eT; + + const T N = x.counter.value(); + + if(N > T(0)) + { + arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch"); + + const uword n_elem = sample.n_elem; + const eT* sample_mem = sample.memptr(); + eT* r_mean_mem = x.r_mean.memptr(); + T* r_var_mem = x.r_var.memptr(); + eT* min_val_mem = x.min_val.memptr(); + eT* max_val_mem = x.max_val.memptr(); + T* min_val_norm_mem = x.min_val_norm.memptr(); + T* max_val_norm_mem = x.max_val_norm.memptr(); + + const T N_plus_1 = x.counter.value_plus_1(); + const T N_minus_1 = x.counter.value_minus_1(); + + if(x.calc_cov == true) + { + Mat& tmp1 = x.tmp1; + Mat& tmp2 = x.tmp2; + + tmp1 = sample - x.r_mean; + + if(sample.n_cols == 1) + { + tmp2 = arma::conj(tmp1)*strans(tmp1); + } + else + { + tmp2 = trans(tmp1)*tmp1; //tmp2 = strans(conj(tmp1))*tmp1; + } + + x.r_cov *= (N_minus_1/N); + x.r_cov += tmp2 / N_plus_1; + } + + + for(uword i=0; i max_val_norm_mem[i]) + { + max_val_norm_mem[i] = val_norm; + max_val_mem[i] = val; + } + + const eT& r_mean_val = r_mean_mem[i]; + + r_var_mem[i] = N_minus_1/N * r_var_mem[i] + std::norm(val - r_mean_val)/N_plus_1; + + r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1; + } + + } + else + { + arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector"); + + x.r_mean.set_size(sample.n_rows, sample.n_cols); + + x.r_var.zeros(sample.n_rows, sample.n_cols); + + if(x.calc_cov == true) + { + x.r_cov.zeros(sample.n_elem, sample.n_elem); + } + + x.min_val.set_size(sample.n_rows, sample.n_cols); + x.max_val.set_size(sample.n_rows, sample.n_cols); + + x.min_val_norm.set_size(sample.n_rows, sample.n_cols); + x.max_val_norm.set_size(sample.n_rows, sample.n_cols); + + + const uword n_elem = sample.n_elem; + const eT* sample_mem = sample.memptr(); + eT* r_mean_mem = x.r_mean.memptr(); + eT* min_val_mem = x.min_val.memptr(); + eT* max_val_mem = x.max_val.memptr(); + T* min_val_norm_mem = x.min_val_norm.memptr(); + T* max_val_norm_mem = x.max_val_norm.memptr(); + + for(uword i=0; i +class span_base + { + public: + static const span_alt all; + }; + + +template +const span_alt span_base::all = span_alt(); + + +class span : public span_base<> + { + public: + + uword a; + uword b; + bool whole; + + inline + span() + : whole(true) + { + } + + + inline + span(const span_alt&) + : whole(true) + { + } + + // TODO: + // if the "explicit" keyword is removed or commented out, + // the compiler will be able to automatically convert integers to an instance of the span class. + // this is useful for Cube::operator()(span&, span&, span&), + // but it might have unintended consequences or interactions elsewhere. + // as such, removal of "explicit" needs thorough testing. + inline + explicit + span(const uword in_a) + : a(in_a) + , b(in_a) + , whole(false) + { + } + + inline + span(const uword in_a, const uword in_b) + : a(in_a) + , b(in_b) + , whole(false) + { + } + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/strip.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/strip.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,91 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup strip +//! @{ + + + +template +struct strip_diagmat + { + typedef T1 stored_type; + + inline strip_diagmat(const Base& X) + : M(X.get_ref()) + { + arma_extra_debug_sigprint(); + } + + static const bool do_diagmat = false; + + const T1& M; + }; + + + +template +struct strip_diagmat< Op > + { + typedef T1 stored_type; + + inline strip_diagmat(const Op& X) + : M(X.m) + { + arma_extra_debug_sigprint(); + } + + static const bool do_diagmat = true; + + const T1& M; + }; + + + +template +struct strip_inv + { + typedef T1 stored_type; + + inline strip_inv(const T1& X) + : M(X) + { + arma_extra_debug_sigprint(); + } + + static const bool do_inv = false; + + const T1& M; + }; + + + +template +struct strip_inv< Op > + { + typedef T1 stored_type; + + inline strip_inv(const Op& X) + : M(X.m) + { + arma_extra_debug_sigprint(); + } + + static const bool do_inv = true; + + const T1& M; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,254 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// Copyright (C) 2011 James Sanders +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview +//! @{ + + +//! Class for storing data required to construct or apply operations to a submatrix +//! (i.e. where the submatrix starts and ends as well as a reference/pointer to the original matrix), +template +class subview : public Base > + { + public: arma_aligned const Mat& m; + protected: arma_aligned Mat* m_ptr; + + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + const uword aux_row1; + const uword aux_col1; + + const uword n_rows; + const uword n_cols; + const uword n_elem; + + + protected: + + arma_inline subview(const Mat& in_m, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols); + arma_inline subview( Mat& in_m, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols); + + + public: + + inline ~subview(); + + inline void operator+= (const eT val); + inline void operator-= (const eT val); + inline void operator*= (const eT val); + inline void operator/= (const eT val); + + // deliberately returning void + template inline void operator= (const Base& x); + template inline void operator+= (const Base& x); + template inline void operator-= (const Base& x); + template inline void operator%= (const Base& x); + template inline void operator/= (const Base& x); + + inline void operator= (const subview& x); + inline void operator+= (const subview& x); + inline void operator-= (const subview& x); + inline void operator%= (const subview& x); + inline void operator/= (const subview& x); + + inline static void extract(Mat& out, const subview& in); + + inline static void plus_inplace(Mat& out, const subview& in); + inline static void minus_inplace(Mat& out, const subview& in); + inline static void schur_inplace(Mat& out, const subview& in); + inline static void div_inplace(Mat& out, const subview& in); + + inline void fill(const eT val); + inline void zeros(); + inline void ones(); + inline void eye(); + + inline eT& operator[](const uword i); + inline eT operator[](const uword i) const; + + inline eT& operator()(const uword i); + inline eT operator()(const uword i) const; + + inline eT& operator()(const uword in_row, const uword in_col); + inline eT operator()(const uword in_row, const uword in_col) const; + + inline eT& at(const uword in_row, const uword in_col); + inline eT at(const uword in_row, const uword in_col) const; + + arma_inline eT* colptr(const uword in_col); + arma_inline const eT* colptr(const uword in_col) const; + + inline bool check_overlap(const subview& x) const; + + inline bool is_vec() const; + + inline subview_row row(const uword row_num); + inline const subview_row row(const uword row_num) const; + + inline subview_row operator()(const uword row_num, const span& col_span); + inline const subview_row operator()(const uword row_num, const span& col_span) const; + + inline subview_col col(const uword col_num); + inline const subview_col col(const uword col_num) const; + + inline subview_col operator()(const span& row_span, const uword col_num); + inline const subview_col operator()(const span& row_span, const uword col_num) const; + + inline Col unsafe_col(const uword col_num); + inline const Col unsafe_col(const uword col_num) const; + + inline subview rows(const uword in_row1, const uword in_row2); + inline const subview rows(const uword in_row1, const uword in_row2) const; + + inline subview cols(const uword in_col1, const uword in_col2); + inline const subview cols(const uword in_col1, const uword in_col2) const; + + inline subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2); + inline const subview submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const; + + inline subview submat (const span& row_span, const span& col_span); + inline const subview submat (const span& row_span, const span& col_span) const; + + inline subview operator()(const span& row_span, const span& col_span); + inline const subview operator()(const span& row_span, const span& col_span) const; + + inline diagview diag(const sword in_id = 0); + inline const diagview diag(const sword in_id = 0) const; + + inline void swap_rows(const uword in_row1, const uword in_row2); + inline void swap_cols(const uword in_col1, const uword in_col2); + + + // // primitive forward iterator + // class iter + // { + // public: + // + // inline iter(const subview& in_M); + // + // arma_inline eT operator* () const; + // + // inline void operator++(); + // inline void operator++(int); + // + // + // private: + // + // arma_aligned const eT* mem; + // + // arma_aligned uword n_rows; + // + // arma_aligned uword row_start; + // arma_aligned uword row_end_p1; + // + // arma_aligned uword row; + // arma_aligned uword col; + // arma_aligned uword i; + // }; + + + private: + + friend class Mat; + subview(); + }; + + + +template +class subview_col : public subview + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + inline void operator= (const subview& x); + inline void operator= (const subview_col& x); + + template + inline void operator= (const Base& x); + + inline subview_col rows(const uword in_row1, const uword in_row2); + inline const subview_col rows(const uword in_row1, const uword in_row2) const; + + inline subview_col subvec(const uword in_row1, const uword in_row2); + inline const subview_col subvec(const uword in_row1, const uword in_row2) const; + + + protected: + + inline subview_col(const Mat& in_m, const uword in_col); + inline subview_col( Mat& in_m, const uword in_col); + + inline subview_col(const Mat& in_m, const uword in_col, const uword in_row1, const uword in_n_rows); + inline subview_col( Mat& in_m, const uword in_col, const uword in_row1, const uword in_n_rows); + + + private: + + friend class Mat; + friend class Col; + friend class subview; + + subview_col(); + }; + + + +template +class subview_row : public subview + { + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + inline void operator= (const subview& x); + inline void operator= (const subview_row& x); + + template + inline void operator= (const Base& x); + + inline subview_row cols(const uword in_col1, const uword in_col2); + inline const subview_row cols(const uword in_col1, const uword in_col2) const; + + inline subview_row subvec(const uword in_col1, const uword in_col2); + inline const subview_row subvec(const uword in_col1, const uword in_col2) const; + + + protected: + + inline subview_row(const Mat& in_m, const uword in_row); + inline subview_row( Mat& in_m, const uword in_row); + + inline subview_row(const Mat& in_m, const uword in_row, const uword in_col1, const uword in_n_cols); + inline subview_row( Mat& in_m, const uword in_row, const uword in_col1, const uword in_n_cols); + + + private: + + friend class Mat; + friend class Row; + friend class subview; + + subview_row(); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_cube_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_cube_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,121 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview_cube +//! @{ + + +//! Class for storing data required to construct or apply operations to a subcube +//! (i.e. where the subcube starts and ends as well as a reference/pointer to the original cube), +template +class subview_cube : public BaseCube > + { + public: arma_aligned const Cube& m; + protected: arma_aligned Cube* m_ptr; + + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + const uword aux_row1; + const uword aux_col1; + const uword aux_slice1; + + const uword n_rows; + const uword n_cols; + const uword n_elem_slice; + const uword n_slices; + const uword n_elem; + + + protected: + + arma_inline subview_cube(const Cube& in_m, const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices); + arma_inline subview_cube( Cube& in_m, const uword in_row1, const uword in_col1, const uword in_slice1, const uword in_n_rows, const uword in_n_cols, const uword in_n_slices); + + + public: + + inline ~subview_cube(); + + inline void operator+= (const eT val); + inline void operator-= (const eT val); + inline void operator*= (const eT val); + inline void operator/= (const eT val); + + // deliberately returning void + template inline void operator= (const BaseCube& x); + template inline void operator+= (const BaseCube& x); + template inline void operator-= (const BaseCube& x); + template inline void operator%= (const BaseCube& x); + template inline void operator/= (const BaseCube& x); + + inline void operator= (const subview_cube& x); + inline void operator+= (const subview_cube& x); + inline void operator-= (const subview_cube& x); + inline void operator%= (const subview_cube& x); + inline void operator/= (const subview_cube& x); + + template inline void operator= (const Base& x); + template inline void operator+= (const Base& x); + template inline void operator-= (const Base& x); + template inline void operator%= (const Base& x); + template inline void operator/= (const Base& x); + + inline static void extract(Cube& out, const subview_cube& in); + inline static void plus_inplace(Cube& out, const subview_cube& in); + inline static void minus_inplace(Cube& out, const subview_cube& in); + inline static void schur_inplace(Cube& out, const subview_cube& in); + inline static void div_inplace(Cube& out, const subview_cube& in); + + inline static void extract(Mat& out, const subview_cube& in); + inline static void plus_inplace(Mat& out, const subview_cube& in); + inline static void minus_inplace(Mat& out, const subview_cube& in); + inline static void schur_inplace(Mat& out, const subview_cube& in); + inline static void div_inplace(Mat& out, const subview_cube& in); + + inline void fill(const eT val); + inline void zeros(); + inline void ones(); + + inline eT& operator[](const uword i); + inline eT operator[](const uword i) const; + + inline eT& operator()(const uword i); + inline eT operator()(const uword i) const; + + arma_inline eT& operator()(const uword in_row, const uword in_col, const uword in_slice); + arma_inline eT operator()(const uword in_row, const uword in_col, const uword in_slice) const; + + arma_inline eT& at(const uword in_row, const uword in_col, const uword in_slice); + arma_inline eT at(const uword in_row, const uword in_col, const uword in_slice) const; + + arma_inline eT* slice_colptr(const uword in_slice, const uword in_col); + arma_inline const eT* slice_colptr(const uword in_slice, const uword in_col) const; + + inline bool check_overlap(const subview_cube& x) const; + inline bool check_overlap(const Mat& x) const; + + + private: + + friend class Mat; + friend class Cube; + + subview_cube(); + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_cube_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_cube_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1745 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview_cube +//! @{ + + +template +inline +subview_cube::~subview_cube() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +subview_cube::subview_cube + ( + const Cube& in_m, + const uword in_row1, + const uword in_col1, + const uword in_slice1, + const uword in_n_rows, + const uword in_n_cols, + const uword in_n_slices + ) + : m (in_m) + , m_ptr (0) + , aux_row1 (in_row1) + , aux_col1 (in_col1) + , aux_slice1 (in_slice1) + , n_rows (in_n_rows) + , n_cols (in_n_cols) + , n_elem_slice(in_n_rows * in_n_cols) + , n_slices (in_n_slices) + , n_elem (n_elem_slice * in_n_slices) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +subview_cube::subview_cube + ( + Cube& in_m, + const uword in_row1, + const uword in_col1, + const uword in_slice1, + const uword in_n_rows, + const uword in_n_cols, + const uword in_n_slices + ) + : m (in_m) + , m_ptr (&in_m) + , aux_row1 (in_row1) + , aux_col1 (in_col1) + , aux_slice1 (in_slice1) + , n_rows (in_n_rows) + , n_cols (in_n_cols) + , n_elem_slice(in_n_rows * in_n_cols) + , n_slices (in_n_slices) + , n_elem (n_elem_slice * in_n_slices) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +subview_cube::operator+= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + for(uword slice = 0; slice < local_n_slices; ++slice) + { + for(uword col = 0; col < local_n_cols; ++col) + { + arrayops::inplace_plus( slice_colptr(slice,col), val, local_n_rows ); + } + } + } + + + +template +inline +void +subview_cube::operator-= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + for(uword slice = 0; slice < local_n_slices; ++slice) + { + for(uword col = 0; col < local_n_cols; ++col) + { + arrayops::inplace_minus( slice_colptr(slice,col), val, local_n_rows ); + } + } + } + + + +template +inline +void +subview_cube::operator*= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + for(uword slice = 0; slice < local_n_slices; ++slice) + { + for(uword col = 0; col < local_n_cols; ++col) + { + arrayops::inplace_mul( slice_colptr(slice,col), val, local_n_rows ); + } + } + } + + + +template +inline +void +subview_cube::operator/= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + for(uword slice = 0; slice < local_n_slices; ++slice) + { + for(uword col = 0; col < local_n_cols; ++col) + { + arrayops::inplace_div( slice_colptr(slice,col), val, local_n_rows ); + } + } + } + + + +template +template +inline +void +subview_cube::operator= (const BaseCube& in) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(in.get_ref()); + + const Cube& x = tmp.M; + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "copy into subcube"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::copy( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + } + + + +template +template +inline +void +subview_cube::operator+= (const BaseCube& in) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(in.get_ref()); + + const Cube& x = tmp.M; + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "addition"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_plus( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + } + + + +template +template +inline +void +subview_cube::operator-= (const BaseCube& in) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(in.get_ref()); + + const Cube& x = tmp.M; + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "subtraction"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_minus( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + } + + + +template +template +inline +void +subview_cube::operator%= (const BaseCube& in) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(in.get_ref()); + + const Cube& x = tmp.M; + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise multiplication"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_mul( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + } + + + +template +template +inline +void +subview_cube::operator/= (const BaseCube& in) + { + arma_extra_debug_sigprint(); + + const unwrap_cube tmp(in.get_ref()); + + const Cube& x = tmp.M; + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise division"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_div( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + } + + + +//! x.subcube(...) = y.subcube(...) +template +inline +void +subview_cube::operator= (const subview_cube& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Cube* tmp_cube = overlap ? new Cube(x_in.m) : 0; + const subview_cube* tmp_subview_cube = overlap ? new subview_cube(*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.n_rows, x_in.n_cols, x_in.n_slices) : 0; + const subview_cube& x = overlap ? (*tmp_subview_cube) : x_in; + + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "copy into subcube"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::copy( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + + if(overlap) + { + delete tmp_subview_cube; + delete tmp_cube; + } + + } + + + +template +inline +void +subview_cube::operator+= (const subview_cube& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Cube* tmp_cube = overlap ? new Cube(x_in.m) : 0; + const subview_cube* tmp_subview_cube = overlap ? new subview_cube(*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.n_rows, x_in.n_cols, x_in.n_slices) : 0; + const subview_cube& x = overlap ? (*tmp_subview_cube) : x_in; + + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "addition"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_plus( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + + if(overlap) + { + delete tmp_subview_cube; + delete tmp_cube; + } + + } + + + +template +inline +void +subview_cube::operator-= (const subview_cube& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Cube* tmp_cube = overlap ? new Cube(x_in.m) : 0; + const subview_cube* tmp_subview_cube = overlap ? new subview_cube(*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.n_rows, x_in.n_cols, x_in.n_slices) : 0; + const subview_cube& x = overlap ? (*tmp_subview_cube) : x_in; + + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "subtraction"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_minus( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + + if(overlap) + { + delete tmp_subview_cube; + delete tmp_cube; + } + + } + + + +template +inline +void +subview_cube::operator%= (const subview_cube& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Cube* tmp_cube = overlap ? new Cube(x_in.m) : 0; + const subview_cube* tmp_subview_cube = overlap ? new subview_cube(*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.n_rows, x_in.n_cols, x_in.n_slices) : 0; + const subview_cube& x = overlap ? (*tmp_subview_cube) : x_in; + + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise multiplication"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_mul( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + + if(overlap) + { + delete tmp_subview_cube; + delete tmp_cube; + } + + } + + + +template +inline +void +subview_cube::operator/= (const subview_cube& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Cube* tmp_cube = overlap ? new Cube(x_in.m) : 0; + const subview_cube* tmp_subview_cube = overlap ? new subview_cube(*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.n_rows, x_in.n_cols, x_in.n_slices) : 0; + const subview_cube& x = overlap ? (*tmp_subview_cube) : x_in; + + subview_cube& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise division"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + for(uword slice = 0; slice < t_n_slices; ++slice) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_div( t.slice_colptr(slice,col), x.slice_colptr(slice,col), t_n_rows ); + } + } + + if(overlap) + { + delete tmp_subview_cube; + delete tmp_cube; + } + + } + + + +template +template +inline +void +subview_cube::operator= (const Base& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(in.get_ref()); + + const Mat& x = tmp.M; + subview_cube& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if( (t_n_rows == x_n_rows) && (t_n_cols == x_n_cols) && (t_n_slices == 1) ) + { + // interpret the matrix as a cube with one slice + + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::copy( t.slice_colptr(0, col), x.colptr(col), t_n_rows ); + } + } + else + if( (t_n_rows == x_n_rows) && (t_n_cols == 1) && (t_n_slices == x_n_cols) ) + { + for(uword i=0; i < t_n_slices; ++i) + { + arrayops::copy( t.slice_colptr(i, 0), x.colptr(i), t_n_rows ); + } + } + else + if( (t_n_rows == 1) && (t_n_cols == x_n_rows) && (t_n_slices == x_n_cols) ) + { + Cube& Q = *(t.m_ptr); + + const uword t_aux_row1 = t.aux_row1; + const uword t_aux_col1 = t.aux_col1; + const uword t_aux_slice1 = t.aux_slice1; + + for(uword slice=0; slice < t_n_slices; ++slice) + { + const uword mod_slice = t_aux_slice1 + slice; + + const eT* x_colptr = x.colptr(slice); + + uword i,j; + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp_i = x_colptr[i]; + const eT tmp_j = x_colptr[j]; + + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) = tmp_i; + Q.at(t_aux_row1, t_aux_col1 + j, mod_slice) = tmp_j; + } + + if(i < t_n_cols) + { + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) = x_colptr[i]; + } + } + } + else + { + if(arma_config::debug == true) + { + arma_stop( arma_incompat_size_string(t, x, "copy into subcube") ); + } + } + } + + + +template +template +inline +void +subview_cube::operator+= (const Base& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(in.get_ref()); + + const Mat& x = tmp.M; + subview_cube& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if( (t_n_rows == x_n_rows) && (t_n_cols == x_n_cols) && (t_n_slices == 1) ) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_plus( t.slice_colptr(0, col), x.colptr(col), t_n_rows ); + } + } + else + if( (t_n_rows == x_n_rows) && (t_n_cols == 1) && (t_n_slices == x_n_cols) ) + { + for(uword i=0; i < t_n_slices; ++i) + { + arrayops::inplace_plus( t.slice_colptr(i, 0), x.colptr(i), t_n_rows ); + } + } + else + if( (t_n_rows == 1) && (t_n_cols == x_n_rows) && (t_n_slices == x_n_cols) ) + { + Cube& Q = *(t.m_ptr); + + const uword t_aux_row1 = t.aux_row1; + const uword t_aux_col1 = t.aux_col1; + const uword t_aux_slice1 = t.aux_slice1; + + for(uword slice=0; slice < t_n_slices; ++slice) + { + const uword mod_slice = t_aux_slice1 + slice; + + const eT* x_colptr = x.colptr(slice); + + uword i,j; + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp_i = x_colptr[i]; + const eT tmp_j = x_colptr[j]; + + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) += tmp_i; + Q.at(t_aux_row1, t_aux_col1 + j, mod_slice) += tmp_j; + } + + if(i < t_n_cols) + { + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) += x_colptr[i]; + } + } + } + else + { + if(arma_config::debug == true) + { + arma_stop( arma_incompat_size_string(t, x, "addition") ); + } + } + } + + + +template +template +inline +void +subview_cube::operator-= (const Base& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(in.get_ref()); + + const Mat& x = tmp.M; + subview_cube& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if( (t_n_rows == x_n_rows) && (t_n_cols == x_n_cols) && (t_n_slices == 1) ) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_minus( t.slice_colptr(0, col), x.colptr(col), t_n_rows ); + } + } + else + if( (t_n_rows == x_n_rows) && (t_n_cols == 1) && (t_n_slices == x_n_cols) ) + { + for(uword i=0; i < t_n_slices; ++i) + { + arrayops::inplace_minus( t.slice_colptr(i, 0), x.colptr(i), t_n_rows ); + } + } + else + if( (t_n_rows == 1) && (t_n_cols == x_n_rows) && (t_n_slices == x_n_cols) ) + { + Cube& Q = *(t.m_ptr); + + const uword t_aux_row1 = t.aux_row1; + const uword t_aux_col1 = t.aux_col1; + const uword t_aux_slice1 = t.aux_slice1; + + for(uword slice=0; slice < t_n_slices; ++slice) + { + const uword mod_slice = t_aux_slice1 + slice; + + const eT* x_colptr = x.colptr(slice); + + uword i,j; + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp_i = x_colptr[i]; + const eT tmp_j = x_colptr[j]; + + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) -= tmp_i; + Q.at(t_aux_row1, t_aux_col1 + j, mod_slice) -= tmp_j; + } + + if(i < t_n_cols) + { + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) -= x_colptr[i]; + } + } + } + else + { + if(arma_config::debug == true) + { + arma_stop( arma_incompat_size_string(t, x, "subtraction") ); + } + } + } + + + +template +template +inline +void +subview_cube::operator%= (const Base& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(in.get_ref()); + + const Mat& x = tmp.M; + subview_cube& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if( (t_n_rows == x_n_rows) && (t_n_cols == x_n_cols) && (t_n_slices == 1) ) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_mul( t.slice_colptr(0, col), x.colptr(col), t_n_rows ); + } + } + else + if( (t_n_rows == x_n_rows) && (t_n_cols == 1) && (t_n_slices == x_n_cols) ) + { + for(uword i=0; i < t_n_slices; ++i) + { + arrayops::inplace_mul( t.slice_colptr(i, 0), x.colptr(i), t_n_rows ); + } + } + else + if( (t_n_rows == 1) && (t_n_cols == x_n_rows) && (t_n_slices == x_n_cols) ) + { + Cube& Q = *(t.m_ptr); + + const uword t_aux_row1 = t.aux_row1; + const uword t_aux_col1 = t.aux_col1; + const uword t_aux_slice1 = t.aux_slice1; + + for(uword slice=0; slice < t_n_slices; ++slice) + { + const uword mod_slice = t_aux_slice1 + slice; + + const eT* x_colptr = x.colptr(slice); + + uword i,j; + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp_i = x_colptr[i]; + const eT tmp_j = x_colptr[j]; + + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) *= tmp_i; + Q.at(t_aux_row1, t_aux_col1 + j, mod_slice) *= tmp_j; + } + + if(i < t_n_cols) + { + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) *= x_colptr[i]; + } + } + } + else + { + if(arma_config::debug == true) + { + arma_stop( arma_incompat_size_string(t, x, "element-wise multiplication") ); + } + } + } + + + +template +template +inline +void +subview_cube::operator/= (const Base& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp(in.get_ref()); + + const Mat& x = tmp.M; + subview_cube& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + const uword t_n_slices = t.n_slices; + + const uword x_n_rows = x.n_rows; + const uword x_n_cols = x.n_cols; + + if( (t_n_rows == x_n_rows) && (t_n_cols == x_n_cols) && (t_n_slices == 1) ) + { + for(uword col = 0; col < t_n_cols; ++col) + { + arrayops::inplace_div( t.slice_colptr(0, col), x.colptr(col), t_n_rows ); + } + } + else + if( (t_n_rows == x_n_rows) && (t_n_cols == 1) && (t_n_slices == x_n_cols) ) + { + for(uword i=0; i < t_n_slices; ++i) + { + arrayops::inplace_div( t.slice_colptr(i, 0), x.colptr(i), t_n_rows ); + } + } + else + if( (t_n_rows == 1) && (t_n_cols == x_n_rows) && (t_n_slices == x_n_cols) ) + { + Cube& Q = *(t.m_ptr); + + const uword t_aux_row1 = t.aux_row1; + const uword t_aux_col1 = t.aux_col1; + const uword t_aux_slice1 = t.aux_slice1; + + for(uword slice=0; slice < t_n_slices; ++slice) + { + const uword mod_slice = t_aux_slice1 + slice; + + const eT* x_colptr = x.colptr(slice); + + uword i,j; + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp_i = x_colptr[i]; + const eT tmp_j = x_colptr[j]; + + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) /= tmp_i; + Q.at(t_aux_row1, t_aux_col1 + j, mod_slice) /= tmp_j; + } + + if(i < t_n_cols) + { + Q.at(t_aux_row1, t_aux_col1 + i, mod_slice) /= x_colptr[i]; + } + } + } + else + { + if(arma_config::debug == true) + { + arma_stop( arma_incompat_size_string(t, x, "element-wise division") ); + } + } + } + + + +template +inline +void +subview_cube::fill(const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + const uword local_n_slices = n_slices; + + for(uword slice = 0; slice < local_n_slices; ++slice) + { + for(uword col = 0; col < local_n_cols; ++col) + { + arrayops::inplace_set( slice_colptr(slice,col), val, local_n_rows ); + } + } + + } + + + +template +inline +void +subview_cube::zeros() + { + arma_extra_debug_sigprint(); + + fill(eT(0)); + } + + + +template +inline +void +subview_cube::ones() + { + arma_extra_debug_sigprint(); + + fill(eT(1)); + } + + + +template +inline +eT& +subview_cube::operator[](const uword i) + { + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + const uword in_col = j / n_rows; + const uword in_row = j % n_rows; + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview_cube::operator[](const uword i) const + { + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + const uword in_col = j / n_rows; + const uword in_row = j % n_rows; + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +inline +eT& +subview_cube::operator()(const uword i) + { + arma_debug_check( (i >= n_elem), "subview_cube::operator(): index out of bounds"); + + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + const uword in_col = j / n_rows; + const uword in_row = j % n_rows; + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview_cube::operator()(const uword i) const + { + arma_debug_check( (i >= n_elem), "subview_cube::operator(): index out of bounds"); + + const uword in_slice = i / n_elem_slice; + const uword offset = in_slice * n_elem_slice; + const uword j = i - offset; + + const uword in_col = j / n_rows; + const uword in_row = j % n_rows; + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +arma_inline +eT& +subview_cube::operator()(const uword in_row, const uword in_col, const uword in_slice) + { + arma_debug_check( ( (in_row >= n_rows) || (in_col >= n_cols) || (in_slice >= n_slices) ), "subview_cube::operator(): location out of bounds"); + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +arma_inline +eT +subview_cube::operator()(const uword in_row, const uword in_col, const uword in_slice) const + { + arma_debug_check( ( (in_row >= n_rows) || (in_col >= n_cols) || (in_slice >= n_slices) ), "subview_cube::operator(): location out of bounds"); + + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +arma_inline +eT& +subview_cube::at(const uword in_row, const uword in_col, const uword in_slice) + { + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +arma_inline +eT +subview_cube::at(const uword in_row, const uword in_col, const uword in_slice) const + { + const uword index = (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +arma_inline +eT* +subview_cube::slice_colptr(const uword in_slice, const uword in_col) + { + return & access::rw((*m_ptr).mem[ (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 ]); + } + + + +template +arma_inline +const eT* +subview_cube::slice_colptr(const uword in_slice, const uword in_col) const + { + return & m.mem[ (in_slice + aux_slice1)*m.n_elem_slice + (in_col + aux_col1)*m.n_rows + aux_row1 ]; + } + + + +template +inline +bool +subview_cube::check_overlap(const subview_cube& x) const + { + const subview_cube& t = *this; + + if(&t.m != &x.m) + { + return false; + } + else + { + if( (t.n_elem == 0) || (x.n_elem == 0) ) + { + return false; + } + else + { + const uword t_row_start = t.aux_row1; + const uword t_row_end_p1 = t_row_start + t.n_rows; + + const uword t_col_start = t.aux_col1; + const uword t_col_end_p1 = t_col_start + t.n_cols; + + const uword t_slice_start = t.aux_slice1; + const uword t_slice_end_p1 = t_slice_start + t.n_slices; + + + const uword x_row_start = x.aux_row1; + const uword x_row_end_p1 = x_row_start + x.n_rows; + + const uword x_col_start = x.aux_col1; + const uword x_col_end_p1 = x_col_start + x.n_cols; + + const uword x_slice_start = x.aux_slice1; + const uword x_slice_end_p1 = x_slice_start + x.n_slices; + + + const bool outside_rows = ( (x_row_start >= t_row_end_p1 ) || (t_row_start >= x_row_end_p1 ) ); + const bool outside_cols = ( (x_col_start >= t_col_end_p1 ) || (t_col_start >= x_col_end_p1 ) ); + const bool outside_slices = ( (x_slice_start >= t_slice_end_p1) || (t_slice_start >= x_slice_end_p1) ); + + return ( (outside_rows == false) && (outside_cols == false) && (outside_slices == false) ); + } + } + } + + + +template +inline +bool +subview_cube::check_overlap(const Mat& x) const + { + const subview_cube& t = *this; + + const uword t_aux_slice1 = t.aux_slice1; + const uword t_aux_slice2_plus_1 = t_aux_slice1 + t.n_slices; + + for(uword slice = t_aux_slice1; slice < t_aux_slice2_plus_1; ++slice) + { + const Mat& y = *(t.m.mat_ptrs[slice]); + + if( x.memptr() == y.memptr() ) + { + return true; + } + } + + return false; + } + + + +//! cube X = Y.subcube(...) +template +inline +void +subview_cube::extract(Cube& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + // NOTE: we're assuming that the cube has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Cube contructor or operator=() + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + const uword n_slices = in.n_slices; + + arma_extra_debug_print(arma_boost::format("out.n_rows = %d out.n_cols = %d out.n_slices = %d in.m.n_rows = %d in.m.n_cols = %d in.m.n_slices = %d") % out.n_rows % out.n_cols % out.n_slices % in.m.n_rows % in.m.n_cols % in.m.n_slices); + + + for(uword slice = 0; slice < n_slices; ++slice) + { + for(uword col = 0; col < n_cols; ++col) + { + arrayops::copy( out.slice_colptr(slice,col), in.slice_colptr(slice,col), n_rows ); + } + } + } + + + +//! cube X += Y.subcube(...) +template +inline +void +subview_cube::plus_inplace(Cube& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "addition"); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_slices = out.n_slices; + + for(uword slice = 0; slice +inline +void +subview_cube::minus_inplace(Cube& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "subtraction"); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_slices = out.n_slices; + + for(uword slice = 0; slice +inline +void +subview_cube::schur_inplace(Cube& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "element-wise multiplication"); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_slices = out.n_slices; + + for(uword slice = 0; slice +inline +void +subview_cube::div_inplace(Cube& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "element-wise division"); + + const uword n_rows = out.n_rows; + const uword n_cols = out.n_cols; + const uword n_slices = out.n_slices; + + for(uword slice = 0; slice +inline +void +subview_cube::extract(Mat& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_cube_as_mat(out, in, "copy into matrix", false); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + out.set_size(in_n_rows, in_n_cols); + + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::copy( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if(in_n_cols == 1) + { + out.set_size(in_n_rows, in_n_slices); + + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::copy( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if(in_n_rows == 1) + { + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + out.set_size(in_n_cols, in_n_slices); + + for(uword slice=0; slice < in_n_slices; ++slice) + { + const uword mod_slice = in_aux_slice1 + slice; + + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + const eT tmp_j = Q.at(in_aux_row1, in_aux_col1 + j, mod_slice); + + out_colptr[i] = tmp_i; + out_colptr[j] = tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + } + } + } + } + else + { + out.set_size(in_n_slices); + + eT* out_mem = out.memptr(); + + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword i=0; i +inline +void +subview_cube::plus_inplace(Mat& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_cube_as_mat(out, in, "addition", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_plus( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_plus( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword slice=0; slice < in_n_slices; ++slice) + { + const uword mod_slice = in_aux_slice1 + slice; + + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + const eT tmp_j = Q.at(in_aux_row1, in_aux_col1 + j, mod_slice); + + out_colptr[i] += tmp_i; + out_colptr[j] += tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] += Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword i=0; i +inline +void +subview_cube::minus_inplace(Mat& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_cube_as_mat(out, in, "subtraction", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_minus( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_minus( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword slice=0; slice < in_n_slices; ++slice) + { + const uword mod_slice = in_aux_slice1 + slice; + + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + const eT tmp_j = Q.at(in_aux_row1, in_aux_col1 + j, mod_slice); + + out_colptr[i] -= tmp_i; + out_colptr[j] -= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] -= Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword i=0; i +inline +void +subview_cube::schur_inplace(Mat& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_cube_as_mat(out, in, "element-wise multiplication", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_mul( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_mul( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword slice=0; slice < in_n_slices; ++slice) + { + const uword mod_slice = in_aux_slice1 + slice; + + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + const eT tmp_j = Q.at(in_aux_row1, in_aux_col1 + j, mod_slice); + + out_colptr[i] *= tmp_i; + out_colptr[j] *= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] *= Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword i=0; i +inline +void +subview_cube::div_inplace(Mat& out, const subview_cube& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_cube_as_mat(out, in, "element-wise division", true); + + const uword in_n_rows = in.n_rows; + const uword in_n_cols = in.n_cols; + const uword in_n_slices = in.n_slices; + + const uword out_n_rows = out.n_rows; + const uword out_n_cols = out.n_cols; + const uword out_vec_state = out.vec_state; + + if(in_n_slices == 1) + { + for(uword col=0; col < in_n_cols; ++col) + { + arrayops::inplace_div( out.colptr(col), in.slice_colptr(0, col), in_n_rows ); + } + } + else + { + if(out_vec_state == 0) + { + if( (in_n_rows == out_n_rows) && (in_n_cols == 1) && (in_n_slices == out_n_cols) ) + { + for(uword i=0; i < in_n_slices; ++i) + { + arrayops::inplace_div( out.colptr(i), in.slice_colptr(i, 0), in_n_rows ); + } + } + else + if( (in_n_rows == 1) && (in_n_cols == out_n_rows) && (in_n_slices == out_n_cols) ) + { + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword slice=0; slice < in_n_slices; ++slice) + { + const uword mod_slice = in_aux_slice1 + slice; + + eT* out_colptr = out.colptr(slice); + + uword i,j; + for(i=0, j=1; j < in_n_cols; i+=2, j+=2) + { + const eT tmp_i = Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + const eT tmp_j = Q.at(in_aux_row1, in_aux_col1 + j, mod_slice); + + out_colptr[i] /= tmp_i; + out_colptr[j] /= tmp_j; + } + + if(i < in_n_cols) + { + out_colptr[i] /= Q.at(in_aux_row1, in_aux_col1 + i, mod_slice); + } + } + } + } + else + { + eT* out_mem = out.memptr(); + + const Cube& Q = in.m; + + const uword in_aux_row1 = in.aux_row1; + const uword in_aux_col1 = in.aux_col1; + const uword in_aux_slice1 = in.aux_slice1; + + for(uword i=0; i +class subview_elem1 : public Base > + { + public: arma_aligned const Mat& m; + protected: arma_aligned Mat* m_ptr; + + public: + + typedef eT elem_type; + typedef typename get_pod_type::result pod_type; + + arma_aligned const Base& a; + + + protected: + + arma_inline subview_elem1(const Mat& in_m, const Base& in_a); + arma_inline subview_elem1( Mat& in_m, const Base& in_a); + + + public: + + inline ~subview_elem1(); + + template inline void inplace_op(const eT val); + template inline void inplace_op(const subview_elem1& x ); + template inline void inplace_op(const Base& x ); + + inline void fill(const eT val); + inline void zeros(); + inline void ones(); + + inline void operator+= (const eT val); + inline void operator-= (const eT val); + inline void operator*= (const eT val); + inline void operator/= (const eT val); + + + // deliberately returning void + template inline void operator_equ(const subview_elem1& x); + template inline void operator= (const subview_elem1& x); + inline void operator= (const subview_elem1& x); + template inline void operator+= (const subview_elem1& x); + template inline void operator-= (const subview_elem1& x); + template inline void operator%= (const subview_elem1& x); + template inline void operator/= (const subview_elem1& x); + + template inline void operator= (const Base& x); + template inline void operator+= (const Base& x); + template inline void operator-= (const Base& x); + template inline void operator%= (const Base& x); + template inline void operator/= (const Base& x); + + inline static void extract(Mat& out, const subview_elem1& in); + + template inline static void mat_inplace_op(Mat& out, const subview_elem1& in); + + inline static void plus_inplace(Mat& out, const subview_elem1& in); + inline static void minus_inplace(Mat& out, const subview_elem1& in); + inline static void schur_inplace(Mat& out, const subview_elem1& in); + inline static void div_inplace(Mat& out, const subview_elem1& in); + + + + private: + + friend class Mat; + subview_elem1(); + }; + + + +class op_subview_elem_equ; +class op_subview_elem_inplace_plus; +class op_subview_elem_inplace_minus; +class op_subview_elem_inplace_schur; +class op_subview_elem_inplace_div; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_elem1_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_elem1_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,729 @@ +// Copyright (C) 2010-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2010-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview_elem1 +//! @{ + + +template +inline +subview_elem1::~subview_elem1() + { + arma_extra_debug_sigprint(); + } + + +template +arma_inline +subview_elem1::subview_elem1(const Mat& in_m, const Base& in_a) + : m(in_m) + , m_ptr(0) + , a(in_a) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +subview_elem1::subview_elem1(Mat& in_m, const Base& in_a) + : m(in_m) + , m_ptr(&in_m) + , a(in_a) + { + arma_extra_debug_sigprint(); + } + + + +template +template +inline +void +subview_elem1::inplace_op(const eT val) + { + Mat& m_local = *m_ptr; + + eT* m_mem = m_local.memptr(); + const uword m_n_elem = m_local.n_elem; + + const unwrap_check_mixed tmp(a.get_ref(), m_local); + const umat& aa = tmp.M; + + arma_debug_check + ( + ( aa.is_vec() == false ), + "Mat::elem(): given object is not a vector" + ); + + const uword* aa_mem = aa.memptr(); + const uword aa_n_elem = aa.n_elem; + + uword i,j; + for(i=0, j=1; j= m_n_elem) || (jj >= m_n_elem) ), "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = val; m_mem[jj] = val; } + else if(is_same_type::value == true) { m_mem[ii] += val; m_mem[jj] += val; } + else if(is_same_type::value == true) { m_mem[ii] -= val; m_mem[jj] -= val; } + else if(is_same_type::value == true) { m_mem[ii] *= val; m_mem[jj] *= val; } + else if(is_same_type::value == true) { m_mem[ii] /= val; m_mem[jj] /= val; } + } + + if(i < aa_n_elem) + { + const uword ii = aa_mem[i]; + + arma_debug_check( (ii >= m_n_elem) , "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = val; } + else if(is_same_type::value == true) { m_mem[ii] += val; } + else if(is_same_type::value == true) { m_mem[ii] -= val; } + else if(is_same_type::value == true) { m_mem[ii] *= val; } + else if(is_same_type::value == true) { m_mem[ii] /= val; } + } + } + + + +template +template +inline +void +subview_elem1::inplace_op(const subview_elem1& x) + { + subview_elem1& t = *this; + + if(&(t.m) == &(x.m)) + { + arma_extra_debug_print("subview_elem1::inplace_op(): aliasing detected"); + + const Mat tmp(x); + + if(is_same_type::value == true) { t.operator= (tmp); } + else if(is_same_type::value == true) { t.operator+=(tmp); } + else if(is_same_type::value == true) { t.operator-=(tmp); } + else if(is_same_type::value == true) { t.operator%=(tmp); } + else if(is_same_type::value == true) { t.operator/=(tmp); } + } + else + { + Mat& t_m_local = *(t.m_ptr); + const Mat& x_m_local = x.m; + + const unwrap_check_mixed t_tmp(t.a.get_ref(), t_m_local); + const unwrap_check_mixed x_tmp(x.a.get_ref(), t_m_local); + + const umat& t_aa = t_tmp.M; + const umat& x_aa = x_tmp.M; + + arma_debug_check + ( + ( (t_aa.is_vec() == false) || (x_aa.is_vec() == false) ), + "Mat::elem(): given object is not a vector" + ); + + const uword* t_aa_mem = t_aa.memptr(); + const uword* x_aa_mem = x_aa.memptr(); + + const uword t_aa_n_elem = t_aa.n_elem; + + arma_debug_check( (t_aa_n_elem != x_aa.n_elem), "Mat::elem(): size mismatch" ); + + + eT* t_m_mem = t_m_local.memptr(); + const uword t_m_n_elem = t_m_local.n_elem; + + const eT* x_m_mem = x_m_local.memptr(); + const uword x_m_n_elem = x_m_local.n_elem; + + uword i,j; + for(i=0, j=1; j= t_m_n_elem) || (t_jj >= t_m_n_elem) || (x_ii >= x_m_n_elem) || (x_jj >= x_m_n_elem), + "Mat::elem(): index out of bounds" + ); + + if(is_same_type::value == true) { t_m_mem[t_ii] = x_m_mem[x_ii]; t_m_mem[t_jj] = x_m_mem[x_jj]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] += x_m_mem[x_ii]; t_m_mem[t_jj] += x_m_mem[x_jj]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] -= x_m_mem[x_ii]; t_m_mem[t_jj] -= x_m_mem[x_jj]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] *= x_m_mem[x_ii]; t_m_mem[t_jj] *= x_m_mem[x_jj]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] /= x_m_mem[x_ii]; t_m_mem[t_jj] /= x_m_mem[x_jj]; } + } + + if(i < t_aa_n_elem) + { + const uword t_ii = t_aa_mem[i]; + const uword x_ii = x_aa_mem[i]; + + arma_debug_check + ( + ( (t_ii >= t_m_n_elem) || (x_ii >= x_m_n_elem) ), + "Mat::elem(): index out of bounds" + ); + + if(is_same_type::value == true) { t_m_mem[t_ii] = x_m_mem[x_ii]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] += x_m_mem[x_ii]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] -= x_m_mem[x_ii]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] *= x_m_mem[x_ii]; } + else if(is_same_type::value == true) { t_m_mem[t_ii] /= x_m_mem[x_ii]; } + } + } + } + + + +template +template +inline +void +subview_elem1::inplace_op(const Base& x) + { + arma_extra_debug_sigprint(); + + Mat& m_local = *m_ptr; + + eT* m_mem = m_local.memptr(); + const uword m_n_elem = m_local.n_elem; + + const unwrap_check_mixed tmp(a.get_ref(), m_local); + const umat& aa = tmp.M; + + arma_debug_check + ( + ( aa.is_vec() == false ), + "Mat::elem(): given object is not a vector" + ); + + const uword* aa_mem = aa.memptr(); + const uword aa_n_elem = aa.n_elem; + + const Proxy P(x.get_ref()); + + arma_debug_check( (aa_n_elem != P.get_n_elem()), "Mat::elem(): size mismatch" ); + + if( (P.is_alias(m) == false) && (Proxy::prefer_at_accessor == false) ) + { + typename Proxy::ea_type X = P.get_ea(); + + uword i,j; + for(i=0, j=1; j= m_n_elem) || (jj >= m_n_elem) ), "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = X[i]; m_mem[jj] = X[j]; } + else if(is_same_type::value == true) { m_mem[ii] += X[i]; m_mem[jj] += X[j]; } + else if(is_same_type::value == true) { m_mem[ii] -= X[i]; m_mem[jj] -= X[j]; } + else if(is_same_type::value == true) { m_mem[ii] *= X[i]; m_mem[jj] *= X[j]; } + else if(is_same_type::value == true) { m_mem[ii] /= X[i]; m_mem[jj] /= X[j]; } + } + + if(i < aa_n_elem) + { + const uword ii = aa_mem[i]; + + arma_debug_check( (ii >= m_n_elem) , "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = X[i]; } + else if(is_same_type::value == true) { m_mem[ii] += X[i]; } + else if(is_same_type::value == true) { m_mem[ii] -= X[i]; } + else if(is_same_type::value == true) { m_mem[ii] *= X[i]; } + else if(is_same_type::value == true) { m_mem[ii] /= X[i]; } + } + } + else + { + arma_extra_debug_print("subview_elem1::inplace_op(): aliasing or prefer_at_accessor detected"); + + const unwrap_check::stored_type> tmp(P.Q, m_local); + const Mat& M = tmp.M; + + const eT* X = M.memptr(); + + uword i,j; + for(i=0, j=1; j= m_n_elem) || (jj >= m_n_elem) ), "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = X[i]; m_mem[jj] = X[j]; } + else if(is_same_type::value == true) { m_mem[ii] += X[i]; m_mem[jj] += X[j]; } + else if(is_same_type::value == true) { m_mem[ii] -= X[i]; m_mem[jj] -= X[j]; } + else if(is_same_type::value == true) { m_mem[ii] *= X[i]; m_mem[jj] *= X[j]; } + else if(is_same_type::value == true) { m_mem[ii] /= X[i]; m_mem[jj] /= X[j]; } + } + + if(i < aa_n_elem) + { + const uword ii = aa_mem[i]; + + arma_debug_check( (ii >= m_n_elem) , "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { m_mem[ii] = X[i]; } + else if(is_same_type::value == true) { m_mem[ii] += X[i]; } + else if(is_same_type::value == true) { m_mem[ii] -= X[i]; } + else if(is_same_type::value == true) { m_mem[ii] *= X[i]; } + else if(is_same_type::value == true) { m_mem[ii] /= X[i]; } + } + } + } + + + +// +// + + + +template +inline +void +subview_elem1::fill(const eT val) + { + arma_extra_debug_sigprint(); + + inplace_op(val); + } + + + +template +inline +void +subview_elem1::zeros() + { + arma_extra_debug_sigprint(); + + inplace_op(eT(0)); + } + + + +template +inline +void +subview_elem1::ones() + { + arma_extra_debug_sigprint(); + + inplace_op(eT(1)); + } + + + +template +inline +void +subview_elem1::operator+= (const eT val) + { + arma_extra_debug_sigprint(); + + inplace_op(val); + } + + + +template +inline +void +subview_elem1::operator-= (const eT val) + { + arma_extra_debug_sigprint(); + + inplace_op(val); + } + + + +template +inline +void +subview_elem1::operator*= (const eT val) + { + arma_extra_debug_sigprint(); + + inplace_op(val); + } + + + +template +inline +void +subview_elem1::operator/= (const eT val) + { + arma_extra_debug_sigprint(); + + inplace_op(val); + } + + + +// +// + + + +template +template +inline +void +subview_elem1::operator_equ(const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + + +template +template +inline +void +subview_elem1::operator= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + (*this).operator_equ(x); + } + + + +//! work around compiler bugs +template +inline +void +subview_elem1::operator= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + (*this).operator_equ(x); + } + + + +template +template +inline +void +subview_elem1::operator+= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator-= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator%= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator/= (const subview_elem1& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator= (const Base& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator+= (const Base& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator-= (const Base& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator%= (const Base& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +template +template +inline +void +subview_elem1::operator/= (const Base& x) + { + arma_extra_debug_sigprint(); + + inplace_op(x); + } + + + +// +// + + + +template +inline +void +subview_elem1::extract(Mat& actual_out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + const unwrap_check_mixed tmp1(in.a.get_ref(), actual_out); + const umat& aa = tmp1.M; + + arma_debug_check + ( + ( aa.is_vec() == false ), + "Mat::elem(): given object is not a vector" + ); + + const uword* aa_mem = aa.memptr(); + const uword aa_n_elem = aa.n_elem; + + const Mat& m_local = in.m; + + const eT* m_mem = m_local.memptr(); + const uword m_n_elem = m_local.n_elem; + + const bool alias = (&actual_out == &m_local); + + arma_extra_debug_warn(alias, "subview_elem1::extract(): aliasing detected"); + + Mat* tmp_out = alias ? new Mat() : 0; + Mat& out = alias ? *tmp_out : actual_out; + + out.set_size(aa_n_elem, 1); + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j= m_n_elem) || (jj >= m_n_elem) ), "Mat::elem(): index out of bounds" ); + + out_mem[i] = m_mem[ii]; + out_mem[j] = m_mem[jj]; + } + + if(i < aa_n_elem) + { + const uword ii = aa_mem[i]; + + arma_debug_check( (ii >= m_n_elem) , "Mat::elem(): index out of bounds" ); + + out_mem[i] = m_mem[ii]; + } + + if(alias == true) + { + actual_out = out; + delete tmp_out; + } + } + + + +template +template +inline +void +subview_elem1::mat_inplace_op(Mat& out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + const unwrap tmp1(in.a.get_ref()); + const umat& aa = tmp1.M; + + arma_debug_check + ( + ( aa.is_vec() == false ), + "Mat::elem(): given object is not a vector" + ); + + const uword* aa_mem = aa.memptr(); + const uword aa_n_elem = aa.n_elem; + + const unwrap_check< Mat > tmp2(in.m, out); + const Mat& m_local = tmp2.M; + + const eT* m_mem = m_local.memptr(); + const uword m_n_elem = m_local.n_elem; + + arma_debug_check( (out.n_elem != aa_n_elem), "Mat::elem(): size mismatch" ); + + eT* out_mem = out.memptr(); + + uword i,j; + for(i=0, j=1; j= m_n_elem) || (jj >= m_n_elem) ), "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { out_mem[i] += m_mem[ii]; out_mem[j] += m_mem[jj]; } + else if(is_same_type::value == true) { out_mem[i] -= m_mem[ii]; out_mem[j] -= m_mem[jj]; } + else if(is_same_type::value == true) { out_mem[i] *= m_mem[ii]; out_mem[j] *= m_mem[jj]; } + else if(is_same_type::value == true) { out_mem[i] /= m_mem[ii]; out_mem[j] /= m_mem[jj]; } + } + + if(i < aa_n_elem) + { + const uword ii = aa_mem[i]; + + arma_debug_check( (ii >= m_n_elem) , "Mat::elem(): index out of bounds" ); + + if(is_same_type::value == true) { out_mem[i] += m_mem[ii]; } + else if(is_same_type::value == true) { out_mem[i] -= m_mem[ii]; } + else if(is_same_type::value == true) { out_mem[i] *= m_mem[ii]; } + else if(is_same_type::value == true) { out_mem[i] /= m_mem[ii]; } + } + } + + + +template +inline +void +subview_elem1::plus_inplace(Mat& out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + mat_inplace_op(out, in); + } + + + +template +inline +void +subview_elem1::minus_inplace(Mat& out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + mat_inplace_op(out, in); + } + + + +template +inline +void +subview_elem1::schur_inplace(Mat& out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + mat_inplace_op(out, in); + } + + + +template +inline +void +subview_elem1::div_inplace(Mat& out, const subview_elem1& in) + { + arma_extra_debug_sigprint(); + + mat_inplace_op(out, in); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_field_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_field_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,78 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview_field +//! @{ + + +//! Class for storing data required to construct or apply operations to a subfield +//! (i.e. where the subfield starts and ends as well as a reference/pointer to the original field), +template +class subview_field + { + public: const field& f; + protected: field* f_ptr; + + public: + + typedef oT object_type; + + const uword aux_row1; + const uword aux_col1; + + const uword n_rows; + const uword n_cols; + const uword n_elem; + + + protected: + + arma_inline subview_field(const field& in_f, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols); + arma_inline subview_field( field& in_f, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols); + + + public: + + inline ~subview_field(); + + inline void operator= (const field& x); + inline void operator= (const subview_field& x); + + arma_inline oT& operator[](const uword i); + arma_inline const oT& operator[](const uword i) const; + + arma_inline oT& operator()(const uword i); + arma_inline const oT& operator()(const uword i) const; + + arma_inline oT& at(const uword row, const uword col); + arma_inline const oT& at(const uword row, const uword col) const; + + arma_inline oT& operator()(const uword row, const uword col); + arma_inline const oT& operator()(const uword row, const uword col) const; + + inline bool check_overlap(const subview_field& x) const; + + inline static void extract(field& out, const subview_field& in); + + + private: + + friend class field; + + + subview_field(); + //subview_field(const subview_field&); + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/subview_field_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/subview_field_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,341 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup subview_field +//! @{ + + +template +inline +subview_field::~subview_field() + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +subview_field::subview_field + ( + const field& in_f, + const uword in_row1, + const uword in_col1, + const uword in_n_rows, + const uword in_n_cols + ) + : f(in_f) + , f_ptr(0) + , aux_row1(in_row1) + , aux_col1(in_col1) + , n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem(in_n_rows*in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +arma_inline +subview_field::subview_field + ( + field& in_f, + const uword in_row1, + const uword in_col1, + const uword in_n_rows, + const uword in_n_cols + ) + : f(in_f) + , f_ptr(&in_f) + , aux_row1(in_row1) + , aux_col1(in_col1) + , n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem(in_n_rows*in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +subview_field::operator= (const field& x) + { + arma_extra_debug_sigprint(); + + subview_field& t = *this; + + arma_debug_check( (t.n_rows != x.n_rows) || (t.n_cols != x.n_cols), "incompatible field dimensions"); + + for(uword col=0; col +inline +void +subview_field::operator= (const subview_field& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + field* tmp_field = overlap ? new field(x_in.f) : 0; + const subview_field* tmp_subview = overlap ? new subview_field(*tmp_field, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview_field& x = overlap ? (*tmp_subview) : x_in; + + subview_field& t = *this; + + arma_debug_check( (t.n_rows != x.n_rows) || (t.n_cols != x.n_cols), "incompatible field dimensions"); + + for(uword col=0; col +arma_inline +oT& +subview_field::operator[](const uword i) + { + arma_check( (f_ptr == 0), "subview_field::operator[]: field is read-only"); + + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *((*f_ptr).mem[index]); + } + + + +template +arma_inline +const oT& +subview_field::operator[](const uword i) const + { + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *(f.mem[index]); + } + + + +template +arma_inline +oT& +subview_field::operator()(const uword i) + { + arma_check( (f_ptr == 0), "subview_field::operator(): field is read-only"); + arma_debug_check( (i >= n_elem), "subview_field::operator(): index out of bounds"); + + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *((*f_ptr).mem[index]); + } + + + +template +arma_inline +const oT& +subview_field::operator()(const uword i) const + { + arma_debug_check( (i >= n_elem), "subview_field::operator(): index out of bounds"); + + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *(f.mem[index]); + } + + + +template +arma_inline +oT& +subview_field::operator()(const uword in_row, const uword in_col) + { + arma_check( (f_ptr == 0), "subview_field::operator(): field is read-only"); + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "subview_field::operator(): index out of bounds"); + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *((*f_ptr).mem[index]); + } + + + +template +arma_inline +const oT& +subview_field::operator()(const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "subview_field::operator(): index out of bounds"); + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *(f.mem[index]); + } + + + +template +arma_inline +oT& +subview_field::at(const uword in_row, const uword in_col) + { + //arma_extra_debug_sigprint(); + + arma_check( (f_ptr == 0), "subview_field::at(): field is read-only"); + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *((*f_ptr).mem[index]); + } + + + +template +arma_inline +const oT& +subview_field::at(const uword in_row, const uword in_col) const + { + //arma_extra_debug_sigprint(); + + const uword index = (in_col + aux_col1)*f.n_rows + aux_row1 + in_row; + + return *(f.mem[index]); + } + + + +template +inline +bool +subview_field::check_overlap(const subview_field& x) const + { + const subview_field& t = *this; + + if(&t.f != &x.f) + { + return false; + } + else + { + if( (t.n_elem == 0) || (x.n_elem == 0) ) + { + return false; + } + else + { + const uword t_row_start = t.aux_row1; + const uword t_row_end_p1 = t_row_start + t.n_rows; + + const uword t_col_start = t.aux_col1; + const uword t_col_end_p1 = t_col_start + t.n_cols; + + + const uword x_row_start = x.aux_row1; + const uword x_row_end_p1 = x_row_start + x.n_rows; + + const uword x_col_start = x.aux_col1; + const uword x_col_end_p1 = x_col_start + x.n_cols; + + + const bool outside_rows = ( (x_row_start >= t_row_end_p1) || (t_row_start >= x_row_end_p1) ); + const bool outside_cols = ( (x_col_start >= t_col_end_p1) || (t_col_start >= x_col_end_p1) ); + + return ( (outside_rows == false) && (outside_cols == false) ); + } + } + } + + + +//! X = Y.subfield(...) +template +inline +void +subview_field::extract(field& actual_out, const subview_field& in) + { + arma_extra_debug_sigprint(); + + // + const bool alias = (&actual_out == &in.f); + + field* tmp = (alias) ? new field : 0; + field& out = (alias) ? (*tmp) : actual_out; + + // + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + out.set_size(n_rows, n_cols); + + arma_extra_debug_print(arma_boost::format("out.n_rows = %d out.n_cols = %d in.m.n_rows = %d in.m.n_cols = %d") % out.n_rows % out.n_cols % in.f.n_rows % in.f.n_cols ); + + for(uword col = 0; col +inline +subview::~subview() + { + arma_extra_debug_sigprint(); + } + + +template +inline +subview::subview(const Mat& in_m, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols) + : m(in_m) + , m_ptr(0) + , aux_row1(in_row1) + , aux_col1(in_col1) + , n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem(in_n_rows*in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview::subview(Mat& in_m, const uword in_row1, const uword in_col1, const uword in_n_rows, const uword in_n_cols) + : m(in_m) + , m_ptr(&in_m) + , aux_row1(in_row1) + , aux_col1(in_col1) + , n_rows(in_n_rows) + , n_cols(in_n_cols) + , n_elem(in_n_rows*in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +subview::operator+= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_cols = n_cols; + const uword local_n_rows = n_rows; + + if(local_n_rows == 1) + { + Mat& X = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + const uword end_col_plus1 = start_col + local_n_cols; + + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_plus1; i+=2, j+=2) + { + X.at(row, i) += val; + X.at(row, j) += val; + } + + if(i < end_col_plus1) + { + X.at(row, i) += val; + } + } + else + { + for(uword col=0; col +inline +void +subview::operator-= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_cols = n_cols; + const uword local_n_rows = n_rows; + + if(local_n_rows == 1) + { + Mat& X = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + const uword end_col_plus1 = start_col + local_n_cols; + + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_plus1; i+=2, j+=2) + { + X.at(row, i) -= val; + X.at(row, j) -= val; + } + + if(i < end_col_plus1) + { + X.at(row, i) -= val; + } + } + else + { + for(uword col=0; col +inline +void +subview::operator*= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_cols = n_cols; + const uword local_n_rows = n_rows; + + if(local_n_rows == 1) + { + Mat& X = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + const uword end_col_plus1 = start_col + local_n_cols; + + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_plus1; i+=2, j+=2) + { + X.at(row, i) *= val; + X.at(row, j) *= val; + } + + if(i < end_col_plus1) + { + X.at(row, i) *= val; + } + } + else + { + for(uword col=0; col +inline +void +subview::operator/= (const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_cols = n_cols; + const uword local_n_rows = n_rows; + + if(local_n_rows == 1) + { + Mat& X = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + const uword end_col_plus1 = start_col + local_n_cols; + + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_plus1; i+=2, j+=2) + { + X.at(row, i) /= val; + X.at(row, j) /= val; + } + + if(i < end_col_plus1) + { + X.at(row, i) /= val; + } + } + else + { + for(uword col=0; col +template +inline +void +subview::operator= (const Base& in) + { + arma_extra_debug_sigprint(); + + const Proxy P(in.get_ref()); + + subview& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + arma_debug_assert_same_size(t, P, "insert into submatrix"); + + const bool alias = P.is_alias(t.m); + + arma_extra_debug_warn(alias, "aliasing detected"); + + if( (alias == true) || (is_Mat::stored_type>::value == true) ) + { + const unwrap_check::stored_type> tmp(P.Q, t.m); + const Mat& x = tmp.M; + + if(t_n_rows == 1) + { + const eT* x_mem = x.memptr(); + + Mat& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + A.at(row, start_col+i) = x_mem[i]; + A.at(row, start_col+j) = x_mem[j]; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) = x_mem[i]; + } + } + else + { + for(uword col=0; col& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + const eT tmp2 = (Proxy::prefer_at_accessor) ? P.at(0,j) : P[j]; + + A.at(row, start_col+i) = tmp1; + A.at(row, start_col+j) = tmp2; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + } + } + else + { + for(uword col=0; col +template +inline +void +subview::operator+= (const Base& in) + { + arma_extra_debug_sigprint(); + + const Proxy P(in.get_ref()); + + subview& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + arma_debug_assert_same_size(t, P, "addition"); + + const bool alias = P.is_alias(t.m); + + arma_extra_debug_warn(alias, "aliasing detected"); + + if( (alias == true) || (is_Mat::stored_type>::value == true) ) + { + const unwrap_check::stored_type> tmp(P.Q, t.m); + const Mat& x = tmp.M; + + if(t_n_rows == 1) + { + const eT* x_mem = x.memptr(); + + Mat& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + A.at(row, start_col+i) += x_mem[i]; + A.at(row, start_col+j) += x_mem[j]; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) += x_mem[i]; + } + } + else + { + for(uword col=0; col& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + const eT tmp2 = (Proxy::prefer_at_accessor) ? P.at(0,j) : P[j]; + + A.at(row, start_col+i) += tmp1; + A.at(row, start_col+j) += tmp2; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) += (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + } + } + else + { + for(uword col=0; col +template +inline +void +subview::operator-= (const Base& in) + { + arma_extra_debug_sigprint(); + + const Proxy P(in.get_ref()); + + subview& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + arma_debug_assert_same_size(t, P, "subtraction"); + + const bool alias = P.is_alias(t.m); + + if( (alias == true) || (is_Mat::stored_type>::value == true) ) + { + const unwrap_check::stored_type> tmp(P.Q, t.m); + const Mat& x = tmp.M; + + if(t_n_rows == 1) + { + const eT* x_mem = x.memptr(); + + Mat& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + A.at(row, start_col+i) -= x_mem[i]; + A.at(row, start_col+j) -= x_mem[j]; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) -= x_mem[i]; + } + } + else + { + for(uword col=0; col& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + const eT tmp2 = (Proxy::prefer_at_accessor) ? P.at(0,j) : P[j]; + + A.at(row, start_col+i) -= tmp1; + A.at(row, start_col+j) -= tmp2; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) -= (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + } + } + else + { + for(uword col=0; col +template +inline +void +subview::operator%= (const Base& in) + { + arma_extra_debug_sigprint(); + + const Proxy P(in.get_ref()); + + subview& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + arma_debug_assert_same_size(t, P, "element-wise multiplication"); + + const bool alias = P.is_alias(t.m); + + arma_extra_debug_warn(alias, "aliasing detected"); + + if( (alias == true) || (is_Mat::stored_type>::value == true) ) + { + const unwrap_check::stored_type> tmp(P.Q, t.m); + const Mat& x = tmp.M; + + if(t_n_rows == 1) + { + const eT* x_mem = x.memptr(); + + Mat& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + A.at(row, start_col+i) *= x_mem[i]; + A.at(row, start_col+j) *= x_mem[j]; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) *= x_mem[i]; + } + } + else + { + for(uword col=0; col& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + const eT tmp2 = (Proxy::prefer_at_accessor) ? P.at(0,j) : P[j]; + + A.at(row, start_col+i) *= tmp1; + A.at(row, start_col+j) *= tmp2; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) *= (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + } + } + else + { + for(uword col=0; col +template +inline +void +subview::operator/= (const Base& in) + { + arma_extra_debug_sigprint(); + + const Proxy P(in.get_ref()); + + subview& t = *this; + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + arma_debug_assert_same_size(t, P, "element-wise division"); + + const bool alias = P.is_alias(t.m); + + arma_extra_debug_warn(alias, "aliasing detected"); + + if( (alias == true) || (is_Mat::stored_type>::value == true) ) + { + const unwrap_check::stored_type> tmp(P.Q, t.m); + const Mat& x = tmp.M; + + if(t_n_rows == 1) + { + const eT* x_mem = x.memptr(); + + Mat& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + A.at(row, start_col+i) /= x_mem[i]; + A.at(row, start_col+j) /= x_mem[j]; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) /= x_mem[i]; + } + } + else + { + for(uword col=0; col& A = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + const eT tmp2 = (Proxy::prefer_at_accessor) ? P.at(0,j) : P[j]; + + A.at(row, start_col+i) /= tmp1; + A.at(row, start_col+j) /= tmp2; + } + + if(i < t_n_cols) + { + A.at(row, start_col+i) /= (Proxy::prefer_at_accessor) ? P.at(0,i) : P[i]; + } + } + else + { + for(uword col=0; col +inline +void +subview::operator= (const subview& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Mat* tmp_mat = overlap ? new Mat(x_in.m) : 0; + const subview* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview& x = overlap ? (*tmp_subview) : x_in; + + subview& t = *this; + + arma_debug_assert_same_size(t, x, "insert into submatrix"); + + const uword t_n_cols = t.n_cols; + const uword t_n_rows = t.n_rows; + + if(t_n_rows == 1) + { + Mat& A = *(t.m_ptr); + const Mat& B = x.m; + + const uword row_A = t.aux_row1; + const uword row_B = x.aux_row1; + + const uword start_col_A = t.aux_col1; + const uword start_col_B = x.aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = B.at(row_B, start_col_B + i); + const eT tmp2 = B.at(row_B, start_col_B + j); + + A.at(row_A, start_col_A + i) = tmp1; + A.at(row_A, start_col_A + j) = tmp2; + } + + if(i < t_n_cols) + { + A.at(row_A, start_col_A + i) = B.at(row_B, start_col_B + i); + } + } + else + { + for(uword col=0; col +inline +void +subview::operator+= (const subview& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Mat* tmp_mat = overlap ? new Mat(x_in.m) : 0; + const subview* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview& x = overlap ? (*tmp_subview) : x_in; + + subview& t = *this; + + arma_debug_assert_same_size(t, x, "addition"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + if(t_n_rows == 1) + { + Mat& A = *(t.m_ptr); + const Mat& B = x.m; + + const uword row_A = t.aux_row1; + const uword row_B = x.aux_row1; + + const uword start_col_A = t.aux_col1; + const uword start_col_B = x.aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = B.at(row_B, start_col_B + i); + const eT tmp2 = B.at(row_B, start_col_B + j); + + A.at(row_A, start_col_A + i) += tmp1; + A.at(row_A, start_col_A + j) += tmp2; + } + + if(i < t_n_cols) + { + A.at(row_A, start_col_A + i) += B.at(row_B, start_col_B + i); + } + } + else + { + for(uword col=0; col +inline +void +subview::operator-= (const subview& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Mat* tmp_mat = overlap ? new Mat(x_in.m) : 0; + const subview* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview& x = overlap ? (*tmp_subview) : x_in; + + subview& t = *this; + + arma_debug_assert_same_size(t, x, "subtraction"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + if(t_n_rows == 1) + { + Mat& A = *(t.m_ptr); + const Mat& B = x.m; + + const uword row_A = t.aux_row1; + const uword row_B = x.aux_row1; + + const uword start_col_A = t.aux_col1; + const uword start_col_B = x.aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = B.at(row_B, start_col_B + i); + const eT tmp2 = B.at(row_B, start_col_B + j); + + A.at(row_A, start_col_A + i) -= tmp1; + A.at(row_A, start_col_A + j) -= tmp2; + } + + if(i < t_n_cols) + { + A.at(row_A, start_col_A + i) -= B.at(row_B, start_col_B + i); + } + } + else + { + for(uword col=0; col +inline +void +subview::operator%= (const subview& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Mat* tmp_mat = overlap ? new Mat(x_in.m) : 0; + const subview* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview& x = overlap ? (*tmp_subview) : x_in; + + subview& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise multiplication"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + if(t_n_rows == 1) + { + Mat& A = *(t.m_ptr); + const Mat& B = x.m; + + const uword row_A = t.aux_row1; + const uword row_B = x.aux_row1; + + const uword start_col_A = t.aux_col1; + const uword start_col_B = x.aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = B.at(row_B, start_col_B + i); + const eT tmp2 = B.at(row_B, start_col_B + j); + + A.at(row_A, start_col_A + i) *= tmp1; + A.at(row_A, start_col_A + j) *= tmp2; + } + + if(i < t_n_cols) + { + A.at(row_A, start_col_A + i) *= B.at(row_B, start_col_B + i); + } + } + else + { + for(uword col=0; col +inline +void +subview::operator/= (const subview& x_in) + { + arma_extra_debug_sigprint(); + + const bool overlap = check_overlap(x_in); + + Mat* tmp_mat = overlap ? new Mat(x_in.m) : 0; + const subview* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux_row1, x_in.aux_col1, x_in.n_rows, x_in.n_cols) : 0; + const subview& x = overlap ? (*tmp_subview) : x_in; + + subview& t = *this; + + arma_debug_assert_same_size(t, x, "element-wise division"); + + const uword t_n_rows = t.n_rows; + const uword t_n_cols = t.n_cols; + + if(t_n_rows == 1) + { + Mat& A = *(t.m_ptr); + const Mat& B = x.m; + + const uword row_A = t.aux_row1; + const uword row_B = x.aux_row1; + + const uword start_col_A = t.aux_col1; + const uword start_col_B = x.aux_col1; + + uword i,j; + + for(i=0, j=1; j < t_n_cols; i+=2, j+=2) + { + const eT tmp1 = B.at(row_B, start_col_B + i); + const eT tmp2 = B.at(row_B, start_col_B + j); + + A.at(row_A, start_col_A + i) /= tmp1; + A.at(row_A, start_col_A + j) /= tmp2; + } + + if(i < t_n_cols) + { + A.at(row_A, start_col_A + i) /= B.at(row_B, start_col_B + i); + } + } + else + { + for(uword col=0; col +inline +void +subview::fill(const eT val) + { + arma_extra_debug_sigprint(); + + const uword local_n_cols = n_cols; + const uword local_n_rows = n_rows; + + if(local_n_rows == 1) + { + Mat& X = (*m_ptr); + + const uword row = aux_row1; + const uword start_col = aux_col1; + const uword end_col_plus1 = start_col + local_n_cols; + + uword i,j; + + for(i=start_col, j=start_col+1; j < end_col_plus1; i+=2, j+=2) + { + X.at(row, i) = val; + X.at(row, j) = val; + } + + if(i < end_col_plus1) + { + X.at(row, i) = val; + } + } + else + { + for(uword col=0; col +inline +void +subview::zeros() + { + arma_extra_debug_sigprint(); + + (*this).fill(eT(0)); + } + + + +template +inline +void +subview::ones() + { + arma_extra_debug_sigprint(); + + (*this).fill(eT(1)); + } + + + +template +inline +void +subview::eye() + { + arma_extra_debug_sigprint(); + + fill(eT(0)); + + const uword N = (std::min)(n_rows, n_cols); + + for(uword i=0; i +inline +eT& +subview::operator[](const uword i) + { + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview::operator[](const uword i) const + { + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +inline +eT& +subview::operator()(const uword i) + { + arma_debug_check( (i >= n_elem), "subview::operator(): index out of bounds"); + + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview::operator()(const uword i) const + { + arma_debug_check( (i >= n_elem), "subview::operator(): index out of bounds"); + + const uword in_col = i / n_rows; + const uword in_row = i % n_rows; + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +inline +eT& +subview::operator()(const uword in_row, const uword in_col) + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "subview::operator(): index out of bounds"); + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview::operator()(const uword in_row, const uword in_col) const + { + arma_debug_check( ((in_row >= n_rows) || (in_col >= n_cols)), "subview::operator(): index out of bounds"); + + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +inline +eT& +subview::at(const uword in_row, const uword in_col) + { + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return access::rw( (*m_ptr).mem[index] ); + } + + + +template +inline +eT +subview::at(const uword in_row, const uword in_col) const + { + const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; + return m.mem[index]; + } + + + +template +arma_inline +eT* +subview::colptr(const uword in_col) + { + return & access::rw((*m_ptr).mem[ (in_col + aux_col1)*m.n_rows + aux_row1 ]); + } + + + +template +arma_inline +const eT* +subview::colptr(const uword in_col) const + { + return & m.mem[ (in_col + aux_col1)*m.n_rows + aux_row1 ]; + } + + + +template +inline +bool +subview::check_overlap(const subview& x) const + { + const subview& t = *this; + + if(&t.m != &x.m) + { + return false; + } + else + { + if( (t.n_elem == 0) || (x.n_elem == 0) ) + { + return false; + } + else + { + const uword t_row_start = t.aux_row1; + const uword t_row_end_p1 = t_row_start + t.n_rows; + + const uword t_col_start = t.aux_col1; + const uword t_col_end_p1 = t_col_start + t.n_cols; + + + const uword x_row_start = x.aux_row1; + const uword x_row_end_p1 = x_row_start + x.n_rows; + + const uword x_col_start = x.aux_col1; + const uword x_col_end_p1 = x_col_start + x.n_cols; + + + const bool outside_rows = ( (x_row_start >= t_row_end_p1) || (t_row_start >= x_row_end_p1) ); + const bool outside_cols = ( (x_col_start >= t_col_end_p1) || (t_col_start >= x_col_end_p1) ); + + return ( (outside_rows == false) && (outside_cols == false) ); + } + } + } + + + +template +inline +bool +subview::is_vec() const + { + return ( (n_rows == 1) || (n_cols == 1) ); + } + + + +//! X = Y.submat(...) +template +inline +void +subview::extract(Mat& out, const subview& in) + { + arma_extra_debug_sigprint(); + + // NOTE: we're assuming that the matrix has already been set to the correct size and there is no aliasing; + // size setting and alias checking is done by either the Mat contructor or operator=() + + const uword n_rows = in.n_rows; // number of rows in the subview + const uword n_cols = in.n_cols; // number of columns in the subview + + arma_extra_debug_print(arma_boost::format("out.n_rows = %d out.n_cols = %d in.m.n_rows = %d in.m.n_cols = %d") % out.n_rows % out.n_cols % in.m.n_rows % in.m.n_cols ); + + + if(in.is_vec() == true) + { + if(n_cols == 1) // a column vector + { + arma_extra_debug_print("subview::extract(): copying col (going across rows)"); + + // in.colptr(0) the first column of the subview, taking into account any row offset + arrayops::copy( out.memptr(), in.colptr(0), n_rows ); + } + else // a row vector (possibly empty) + { + arma_extra_debug_print("subview::extract(): copying row (going across columns)"); + + const Mat& X = in.m; + + eT* out_mem = out.memptr(); + + const uword row = in.aux_row1; + const uword start_col = in.aux_col1; + + uword i,j; + + for(i=0, j=1; j < n_cols; i+=2, j+=2) + { + const eT tmp1 = X.at(row, start_col+i); + const eT tmp2 = X.at(row, start_col+j); + + out_mem[i] = tmp1; + out_mem[j] = tmp2; + } + + if(i < n_cols) + { + out_mem[i] = X.at(row, start_col+i); + } + } + } + else // general submatrix + { + arma_extra_debug_print("subview::extract(): general submatrix"); + + for(uword col = 0; col +inline +void +subview::plus_inplace(Mat& out, const subview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "addition"); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows == 1) + { + eT* out_mem = out.memptr(); + + const Mat& X = in.m; + + const uword row = in.aux_row1; + const uword start_col = in.aux_col1; + + uword i,j; + for(i=0, j=1; j < n_cols; i+=2, j+=2) + { + const eT tmp1 = X.at(row, start_col+i); + const eT tmp2 = X.at(row, start_col+j); + + out_mem[i] += tmp1; + out_mem[j] += tmp2; + } + + if(i < n_cols) + { + out_mem[i] += X.at(row, start_col+i); + } + } + else + { + for(uword col=0; col +inline +void +subview::minus_inplace(Mat& out, const subview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "subtraction"); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows == 1) + { + eT* out_mem = out.memptr(); + + const Mat& X = in.m; + + const uword row = in.aux_row1; + const uword start_col = in.aux_col1; + + uword i,j; + for(i=0, j=1; j < n_cols; i+=2, j+=2) + { + const eT tmp1 = X.at(row, start_col+i); + const eT tmp2 = X.at(row, start_col+j); + + out_mem[i] -= tmp1; + out_mem[j] -= tmp2; + } + + if(i < n_cols) + { + out_mem[i] -= X.at(row, start_col+i); + } + } + else + { + for(uword col=0; col +inline +void +subview::schur_inplace(Mat& out, const subview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "element-wise multiplication"); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows == 1) + { + eT* out_mem = out.memptr(); + + const Mat& X = in.m; + + const uword row = in.aux_row1; + const uword start_col = in.aux_col1; + + uword i,j; + for(i=0, j=1; j < n_cols; i+=2, j+=2) + { + const eT tmp1 = X.at(row, start_col+i); + const eT tmp2 = X.at(row, start_col+j); + + out_mem[i] *= tmp1; + out_mem[j] *= tmp2; + } + + if(i < n_cols) + { + out_mem[i] *= X.at(row, start_col+i); + } + } + else + { + for(uword col=0; col +inline +void +subview::div_inplace(Mat& out, const subview& in) + { + arma_extra_debug_sigprint(); + + arma_debug_assert_same_size(out, in, "element-wise division"); + + const uword n_rows = in.n_rows; + const uword n_cols = in.n_cols; + + if(n_rows == 1) + { + eT* out_mem = out.memptr(); + + const Mat& X = in.m; + + const uword row = in.aux_row1; + const uword start_col = in.aux_col1; + + uword i,j; + for(i=0, j=1; j < n_cols; i+=2, j+=2) + { + const eT tmp1 = X.at(row, start_col+i); + const eT tmp2 = X.at(row, start_col+j); + + out_mem[i] /= tmp1; + out_mem[j] /= tmp2; + } + + if(i < n_cols) + { + out_mem[i] /= X.at(row, start_col+i); + } + } + else + { + for(uword col=0; col +inline +subview_row +subview::row(const uword row_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= n_rows, "subview::row(): out of bounds" ); + + const uword base_row = aux_row1 + row_num; + + return subview_row(*m_ptr, base_row, aux_col1, n_cols); + } + + + +//! creation of subview (row vector) +template +inline +const subview_row +subview::row(const uword row_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( row_num >= n_rows, "subview::row(): out of bounds" ); + + const uword base_row = aux_row1 + row_num; + + return subview_row(m, base_row, aux_col1, n_cols); + } + + + +template +inline +subview_row +subview::operator()(const uword row_num, const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + const uword base_col1 = aux_col1 + in_col1; + const uword base_row = aux_row1 + row_num; + + arma_debug_check + ( + (row_num >= n_rows) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "subview::operator(): indices out of bounds or incorrectly used" + ); + + return subview_row(*m_ptr, base_row, base_col1, submat_n_cols); + } + + + +template +inline +const subview_row +subview::operator()(const uword row_num, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool col_all = col_span.whole; + + const uword local_n_cols = n_cols; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + const uword base_col1 = aux_col1 + in_col1; + const uword base_row = aux_row1 + row_num; + + arma_debug_check + ( + (row_num >= n_rows) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "subview::operator(): indices out of bounds or incorrectly used" + ); + + return subview_row(m, base_row, base_col1, submat_n_cols); + } + + + +//! creation of subview (column vector) +template +inline +subview_col +subview::col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "subview::col(): out of bounds"); + + const uword base_col = aux_col1 + col_num; + + return subview_col(*m_ptr, base_col, aux_row1, n_rows); + } + + + +//! creation of subview (column vector) +template +inline +const subview_col +subview::col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "subview::col(): out of bounds"); + + const uword base_col = aux_col1 + col_num; + + return subview_col(m, base_col, aux_row1, n_rows); + } + + + +template +inline +subview_col +subview::operator()(const span& row_span, const uword col_num) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col = aux_col1 + col_num; + + arma_debug_check + ( + (col_num >= n_cols) + || + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + , + "subview::operator(): indices out of bounds or incorrectly used" + ); + + return subview_col(*m_ptr, base_col, base_row1, submat_n_rows); + } + + + +template +inline +const subview_col +subview::operator()(const span& row_span, const uword col_num) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + + const uword local_n_rows = n_rows; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col = aux_col1 + col_num; + + arma_debug_check + ( + (col_num >= n_cols) + || + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + , + "subview::operator(): indices out of bounds or incorrectly used" + ); + + return subview_col(m, base_col, base_row1, submat_n_rows); + } + + + +//! create a Col object which uses memory from an existing matrix object. +//! this approach is currently not alias safe +//! and does not take into account that the parent matrix object could be deleted. +//! if deleted memory is accessed by the created Col object, +//! it will cause memory corruption and/or a crash +template +inline +Col +subview::unsafe_col(const uword col_num) + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "subview::unsafe_col(): out of bounds"); + + return Col(colptr(col_num), n_rows, false, true); + } + + + +//! create a Col object which uses memory from an existing matrix object. +//! this approach is currently not alias safe +//! and does not take into account that the parent matrix object could be deleted. +//! if deleted memory is accessed by the created Col object, +//! it will cause memory corruption and/or a crash +template +inline +const Col +subview::unsafe_col(const uword col_num) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( col_num >= n_cols, "subview::unsafe_col(): out of bounds"); + + return Col(const_cast(colptr(col_num)), n_rows, false, true); + } + + + +//! creation of subview (submatrix comprised of specified row vectors) +template +inline +subview +subview::rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= n_rows), + "subview::rows(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword base_row1 = aux_row1 + in_row1; + + return subview(*m_ptr, base_row1, aux_col1, subview_n_rows, n_cols ); + } + + + +//! creation of subview (submatrix comprised of specified row vectors) +template +inline +const subview +subview::rows(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_row2 >= n_rows), + "subview::rows(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword base_row1 = aux_row1 + in_row1; + + return subview(m, base_row1, aux_col1, subview_n_rows, n_cols ); + } + + + +//! creation of subview (submatrix comprised of specified column vectors) +template +inline +subview +subview::cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= n_cols), + "subview::cols(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(*m_ptr, aux_row1, base_col1, n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix comprised of specified column vectors) +template +inline +const subview +subview::cols(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 > in_col2) || (in_col2 >= n_cols), + "subview::cols(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(m, aux_row1, base_col1, n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix) +template +inline +subview +subview::submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "subview::submat(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(*m_ptr, base_row1, base_col1, subview_n_rows, subview_n_cols); + } + + + +//! creation of subview (generic submatrix) +template +inline +const subview +subview::submat(const uword in_row1, const uword in_col1, const uword in_row2, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 > in_row2) || (in_col1 > in_col2) || (in_row2 >= n_rows) || (in_col2 >= n_cols), + "subview::submat(): indices out of bounds or incorrectly used" + ); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(m, base_row1, base_col1, subview_n_rows, subview_n_cols); + } + + + +//! creation of subview (submatrix) +template +inline +subview +subview::submat(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "subview::submat(): indices out of bounds or incorrectly used" + ); + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(*m_ptr, base_row1, base_col1, submat_n_rows, submat_n_cols); + } + + + +//! creation of subview (generic submatrix) +template +inline +const subview +subview::submat(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + const bool row_all = row_span.whole; + const bool col_all = col_span.whole; + + const uword local_n_rows = n_rows; + const uword local_n_cols = n_cols; + + const uword in_row1 = row_all ? 0 : row_span.a; + const uword in_row2 = row_span.b; + const uword submat_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1; + + const uword in_col1 = col_all ? 0 : col_span.a; + const uword in_col2 = col_span.b; + const uword submat_n_cols = col_all ? local_n_cols : in_col2 - in_col1 + 1; + + arma_debug_check + ( + ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ) + || + ( col_all ? false : ((in_col1 > in_col2) || (in_col2 >= local_n_cols)) ) + , + "subview::submat(): indices out of bounds or incorrectly used" + ); + + const uword base_row1 = aux_row1 + in_row1; + const uword base_col1 = aux_col1 + in_col1; + + return subview(m, base_row1, base_col1, submat_n_rows, submat_n_cols); + } + + + +template +inline +subview +subview::operator()(const span& row_span, const span& col_span) + { + arma_extra_debug_sigprint(); + + return (*this).submat(row_span, col_span); + } + + + +template +inline +const subview +subview::operator()(const span& row_span, const span& col_span) const + { + arma_extra_debug_sigprint(); + + return (*this).submat(row_span, col_span); + } + + + +//! creation of diagview (diagonal) +template +inline +diagview +subview::diag(const sword in_id) + { + arma_extra_debug_sigprint(); + + const uword row_offset = (in_id < 0) ? uword(-in_id) : 0; + const uword col_offset = (in_id > 0) ? uword( in_id) : 0; + + arma_debug_check + ( + ((row_offset > 0) && (row_offset >= n_rows)) || ((col_offset > 0) && (col_offset >= n_cols)), + "subview::diag(): requested diagonal out of bounds" + ); + + const uword len = (std::min)(n_rows - row_offset, n_cols - col_offset); + + const uword base_row_offset = aux_row1 + row_offset; + const uword base_col_offset = aux_col1 + col_offset; + + return diagview(*m_ptr, base_row_offset, base_col_offset, len); + } + + + +//! creation of diagview (diagonal) +template +inline +const diagview +subview::diag(const sword in_id) const + { + arma_extra_debug_sigprint(); + + const uword row_offset = (in_id < 0) ? -in_id : 0; + const uword col_offset = (in_id > 0) ? in_id : 0; + + arma_debug_check + ( + ((row_offset > 0) && (row_offset >= n_rows)) || ((col_offset > 0) && (col_offset >= n_cols)), + "subview::diag(): requested diagonal out of bounds" + ); + + const uword len = (std::min)(n_rows - row_offset, n_cols - col_offset); + + const uword base_row_offset = aux_row1 + row_offset; + const uword base_col_offset = aux_col1 + col_offset; + + return diagview(m, base_row_offset, base_col_offset, len); + } + + + +template +inline +void +subview::swap_rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_row1 >= n_rows) || (in_row2 >= n_rows), + "subview::swap_rows(): out of bounds" + ); + + eT* mem = (*m_ptr).memptr(); + + for(uword col=0; col +inline +void +subview::swap_cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check + ( + (in_col1 >= n_cols) || (in_col2 >= n_cols), + "subview::swap_cols(): out of bounds" + ); + + if(n_elem > 0) + { + eT* ptr1 = colptr(in_col1); + eT* ptr2 = colptr(in_col2); + + for(uword row=0; row +// inline +// subview::iter::iter(const subview& S) +// : mem (S.m.mem) +// , n_rows (S.m.n_rows) +// , row_start (S.aux_row1) +// , row_end_p1(row_start + S.n_rows) +// , row (row_start) +// , col (S.aux_col1) +// , i (row + col*n_rows) +// { +// arma_extra_debug_sigprint(); +// } +// +// +// +// template +// arma_inline +// eT +// subview::iter::operator*() const +// { +// return mem[i]; +// } +// +// +// +// template +// inline +// void +// subview::iter::operator++() +// { +// ++row; +// +// if(row < row_end_p1) +// { +// ++i; +// } +// else +// { +// row = row_start; +// ++col; +// +// i = row + col*n_rows; +// } +// } +// +// +// +// template +// inline +// void +// subview::iter::operator++(int) +// { +// operator++(); +// } + + + +// +// +// + + + +template +inline +subview_col::subview_col(const Mat& in_m, const uword in_col) + : subview(in_m, 0, in_col, in_m.n_rows, 1) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_col::subview_col(Mat& in_m, const uword in_col) + : subview(in_m, 0, in_col, in_m.n_rows, 1) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_col::subview_col(const Mat& in_m, const uword in_col, const uword in_row1, const uword in_n_rows) + : subview(in_m, in_row1, in_col, in_n_rows, 1) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_col::subview_col(Mat& in_m, const uword in_col, const uword in_row1, const uword in_n_rows) + : subview(in_m, in_row1, in_col, in_n_rows, 1) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +subview_col::operator=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); + arma_debug_check( (subview::n_cols > 1), "subview_col(): incompatible dimensions" ); + } + + + +template +inline +void +subview_col::operator=(const subview_col& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); // interprets 'subview_col' as 'subview' + arma_debug_check( (subview::n_cols > 1), "subview_col(): incompatible dimensions" ); + } + + + +template +template +inline +void +subview_col::operator=(const Base& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); + arma_debug_check( (subview::n_cols > 1), "subview_col(): incompatible dimensions" ); + } + + + +template +inline +subview_col +subview_col::rows(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= subview::n_rows) ), "subview_col::rows(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + const uword base_row1 = this->aux_row1 + in_row1; + + return subview_col(*(this->m_ptr), this->aux_col1, base_row1, subview_n_rows); + } + + + +template +inline +const subview_col +subview_col::rows(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= subview::n_rows) ), "subview_col::rows(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + const uword base_row1 = this->aux_row1 + in_row1; + + return subview_col(this->m, this->aux_col1, base_row1, subview_n_rows); + } + + + +template +inline +subview_col +subview_col::subvec(const uword in_row1, const uword in_row2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= subview::n_rows) ), "subview_col::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + const uword base_row1 = this->aux_row1 + in_row1; + + return subview_col(*(this->m_ptr), this->aux_col1, base_row1, subview_n_rows); + } + + + +template +inline +const subview_col +subview_col::subvec(const uword in_row1, const uword in_row2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= subview::n_rows) ), "subview_col::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_rows = in_row2 - in_row1 + 1; + + const uword base_row1 = this->aux_row1 + in_row1; + + return subview_col(this->m, this->aux_col1, base_row1, subview_n_rows); + } + + + +// +// +// + + + +template +inline +subview_row::subview_row(const Mat& in_m, const uword in_row) + : subview(in_m, in_row, 0, 1, in_m.n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_row::subview_row(Mat& in_m, const uword in_row) + : subview(in_m, in_row, 0, 1, in_m.n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_row::subview_row(const Mat& in_m, const uword in_row, const uword in_col1, const uword in_n_cols) + : subview(in_m, in_row, in_col1, 1, in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +subview_row::subview_row(Mat& in_m, const uword in_row, const uword in_col1, const uword in_n_cols) + : subview(in_m, in_row, in_col1, 1, in_n_cols) + { + arma_extra_debug_sigprint(); + } + + + +template +inline +void +subview_row::operator=(const subview& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); + arma_debug_check( (subview::n_rows > 1), "subview_row(): incompatible dimensions" ); + } + + + +template +inline +void +subview_row::operator=(const subview_row& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); // interprets 'subview_row' as 'subview' + arma_debug_check( (subview::n_rows > 1), "subview_row(): incompatible dimensions" ); + } + + + +template +template +inline +void +subview_row::operator=(const Base& X) + { + arma_extra_debug_sigprint(); + + subview::operator=(X); + arma_debug_check( (subview::n_rows > 1), "subview_row(): incompatible dimensions" ); + } + + + +template +inline +subview_row +subview_row::cols(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= subview::n_cols) ), "subview_row::cols(): indices out of bounds or incorrectly used" ); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_col1 = this->aux_col1 + in_col1; + + return subview_row(*(this->m_ptr), this->aux_row1, base_col1, subview_n_cols); + } + + + +template +inline +const subview_row +subview_row::cols(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= subview::n_cols) ), "subview_row::cols(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_col1 = this->aux_col1 + in_col1; + + return subview_row(this->m, this->aux_row1, base_col1, subview_n_cols); + } + + + +template +inline +subview_row +subview_row::subvec(const uword in_col1, const uword in_col2) + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= subview::n_cols) ), "subview_row::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_col1 = this->aux_col1 + in_col1; + + return subview_row(*(this->m_ptr), this->aux_row1, base_col1, subview_n_cols); + } + + + +template +inline +const subview_row +subview_row::subvec(const uword in_col1, const uword in_col2) const + { + arma_extra_debug_sigprint(); + + arma_debug_check( ( (in_col1 > in_col2) || (in_col2 >= subview::n_cols) ), "subview_row::subvec(): indices out of bounds or incorrectly used"); + + const uword subview_n_cols = in_col2 - in_col1 + 1; + + const uword base_col1 = this->aux_col1 + in_col1; + + return subview_row(this->m, this->aux_row1, base_col1, subview_n_cols); + } + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/traits.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/traits.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,672 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup traits +//! @{ + + +template +struct get_pod_type + { typedef T1 result; }; + +template +struct get_pod_type< std::complex > + { typedef T2 result; }; + + + +template +struct is_Mat_only + { static const bool value = false; }; + +template +struct is_Mat_only< Mat > + { static const bool value = true; }; + + + +template +struct is_Mat + { static const bool value = false; }; + +template +struct is_Mat< Mat > + { static const bool value = true; }; + +template +struct is_Mat< Row > + { static const bool value = true; }; + +template +struct is_Mat< Col > + { static const bool value = true; }; + + + +template +struct is_Row + { static const bool value = false; }; + +template +struct is_Row< Row > + { static const bool value = true; }; + + + +template +struct is_Col + { static const bool value = false; }; + +template +struct is_Col< Col > + { static const bool value = true; }; + + + + + + +template +struct is_subview + { static const bool value = false; }; + +template +struct is_subview< subview > + { static const bool value = true; }; + + +template +struct is_diagview + { static const bool value = false; }; + +template +struct is_diagview< diagview > + { static const bool value = true; }; + + +// +// +// + + + +template +struct is_Cube + { static const bool value = false; }; + +template +struct is_Cube< Cube > + { static const bool value = true; }; + +template +struct is_subview_cube + { static const bool value = false; }; + +template +struct is_subview_cube< subview_cube > + { static const bool value = true; }; + + + +// +// +// + + +template +struct is_Gen + { static const bool value = false; }; + +template +struct is_Gen< Gen > + { static const bool value = true; }; + + +template +struct is_Op + { static const bool value = false; }; + +template +struct is_Op< Op > + { static const bool value = true; }; + + +template +struct is_eOp + { static const bool value = false; }; + +template +struct is_eOp< eOp > + { static const bool value = true; }; + + +template +struct is_mtOp + { static const bool value = false; }; + +template +struct is_mtOp< mtOp > + { static const bool value = true; }; + + +template +struct is_Glue + { static const bool value = false; }; + +template +struct is_Glue< Glue > + { static const bool value = true; }; + + +template +struct is_eGlue + { static const bool value = false; }; + +template +struct is_eGlue< eGlue > + { static const bool value = true; }; + + +template +struct is_mtGlue + { static const bool value = false; }; + +template +struct is_mtGlue< mtGlue > + { static const bool value = true; }; + + +// +// + + +template +struct is_glue_times + { static const bool value = false; }; + +template +struct is_glue_times< Glue > + { static const bool value = true; }; + + +template +struct is_glue_times_diag + { static const bool value = false; }; + +template +struct is_glue_times_diag< Glue > + { static const bool value = true; }; + + +template +struct is_op_diagmat + { static const bool value = false; }; + +template +struct is_op_diagmat< Op > + { static const bool value = true; }; + + +// +// + + +template +struct is_GenCube + { static const bool value = false; }; + +template +struct is_GenCube< GenCube > + { static const bool value = true; }; + + +template +struct is_OpCube + { static const bool value = false; }; + +template +struct is_OpCube< OpCube > + { static const bool value = true; }; + + +template +struct is_eOpCube + { static const bool value = false; }; + +template +struct is_eOpCube< eOpCube > + { static const bool value = true; }; + + +template +struct is_mtOpCube + { static const bool value = false; }; + +template +struct is_mtOpCube< mtOpCube > + { static const bool value = true; }; + + +template +struct is_GlueCube + { static const bool value = false; }; + +template +struct is_GlueCube< GlueCube > + { static const bool value = true; }; + + +template +struct is_eGlueCube + { static const bool value = false; }; + +template +struct is_eGlueCube< eGlueCube > + { static const bool value = true; }; + + +template +struct is_mtGlueCube + { static const bool value = false; }; + +template +struct is_mtGlueCube< mtGlueCube > + { static const bool value = true; }; + + +// +// +// + + +template +struct is_op_rel + { static const bool value = false; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + +template +struct is_op_rel< mtOp > + { static const bool value = true; }; + + + +// +// +// + + + +template +struct is_arma_type + { + static const bool value + = is_Mat::value + || is_Gen::value + || is_Op::value + || is_eOp::value + || is_mtOp::value + || is_Glue::value + || is_eGlue::value + || is_mtGlue::value + || is_subview::value + || is_diagview::value + ; + }; + + + +template +struct is_arma_cube_type + { + static const bool value + = is_Cube::value + || is_GenCube::value + || is_OpCube::value + || is_eOpCube::value + || is_mtOpCube::value + || is_GlueCube::value + || is_eGlueCube::value + || is_mtGlueCube::value + || is_subview_cube::value + ; + }; + + + +// +// +// + + +template +struct is_same_type + { static const bool value = false; }; + + +template +struct is_same_type + { static const bool value = true; }; + + + +// +// +// + + +template +struct is_u8 + { static const bool value = false; }; + +template<> +struct is_u8 + { static const bool value = true; }; + + + +template +struct is_s8 + { static const bool value = false; }; + +template<> +struct is_s8 + { static const bool value = true; }; + + + +template +struct is_u16 + { static const bool value = false; }; + +template<> +struct is_u16 + { static const bool value = true; }; + + + +template +struct is_s16 + { static const bool value = false; }; + +template<> +struct is_s16 + { static const bool value = true; }; + + + +template +struct is_u32 + { static const bool value = false; }; + +template<> +struct is_u32 + { static const bool value = true; }; + + + +template +struct is_s32 + { static const bool value = false; }; + +template<> +struct is_s32 + { static const bool value = true; }; + + + +#if defined(ARMA_64BIT_WORD) + template + struct is_u64 + { static const bool value = false; }; + + template<> + struct is_u64 + { static const bool value = true; }; + + + template + struct is_s64 + { static const bool value = false; }; + + template<> + struct is_s64 + { static const bool value = true; }; +#endif + + + +template +struct is_uword + { static const bool value = false; }; + +template<> +struct is_uword + { static const bool value = true; }; + + + +template +struct is_sword + { static const bool value = false; }; + +template<> +struct is_sword + { static const bool value = true; }; + + + +template +struct is_float + { static const bool value = false; }; + +template<> +struct is_float + { static const bool value = true; }; + + + +template +struct is_double + { static const bool value = false; }; + +template<> +struct is_double + { static const bool value = true; }; + + + +template +struct is_complex + { static const bool value = false; }; + +// template<> +template +struct is_complex< std::complex > + { static const bool value = true; }; + + + +template +struct is_complex_float + { static const bool value = false; }; + +template<> +struct is_complex_float< std::complex > + { static const bool value = true; }; + + + +template +struct is_complex_double + { static const bool value = false; }; + +template<> +struct is_complex_double< std::complex > + { static const bool value = true; }; + + + + +//! check for a weird implementation of the std::complex class +template +struct is_supported_complex + { static const bool value = false; }; + +//template<> +template +struct is_supported_complex< std::complex > + { static const bool value = ( sizeof(std::complex) == 2*sizeof(eT) ); }; + + + +template +struct is_supported_complex_float + { static const bool value = false; }; + +template<> +struct is_supported_complex_float< std::complex > + { static const bool value = ( sizeof(std::complex) == 2*sizeof(float) ); }; + + + +template +struct is_supported_complex_double + { static const bool value = false; }; + +template<> +struct is_supported_complex_double< std::complex > + { static const bool value = ( sizeof(std::complex) == 2*sizeof(double) ); }; + + + +template +struct is_supported_elem_type + { + static const bool value = \ + is_u8::value || + is_s8::value || + is_u16::value || + is_s16::value || + is_u32::value || + is_s32::value || +#if defined(ARMA_64BIT_WORD) + is_u64::value || + is_s64::value || +#endif + is_float::value || + is_double::value || + is_supported_complex_float::value || + is_supported_complex_double::value; + }; + + + +template +struct is_supported_blas_type + { + static const bool value = \ + is_float::value || + is_double::value || + is_supported_complex_float::value || + is_supported_complex_double::value; + }; + + + +template +struct is_signed + { + static const bool value = true; + }; + + +template<> struct is_signed { static const bool value = false; }; +template<> struct is_signed { static const bool value = false; }; +template<> struct is_signed { static const bool value = false; }; +#if defined(ARMA_64BIT_WORD) +template<> struct is_signed { static const bool value = false; }; +#endif + + +template +struct is_non_integral + { + static const bool value = false; + }; + + +template<> struct is_non_integral< float > { static const bool value = true; }; +template<> struct is_non_integral< double > { static const bool value = true; }; +template<> struct is_non_integral< std::complex > { static const bool value = true; }; +template<> struct is_non_integral< std::complex > { static const bool value = true; }; + + + + +// + +class arma_junk_class; + +template +struct force_different_type + { + typedef T1 T1_result; + typedef T2 T2_result; + }; + + +template +struct force_different_type + { + typedef T1 T1_result; + typedef arma_junk_class T2_result; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/typedef.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/typedef.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,198 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup typedef +//! @{ + + +#if UCHAR_MAX >= 0xff + //! unsigned 8 bit type + typedef unsigned char u8; + typedef char s8; +#else + #error "don't know how to typedef 'u8' on this system" +#endif + +// NOTE: +// "signed char" is not the same as "char". +// http://www.embedded.com/columns/programmingpointers/206107018 +// http://en.wikipedia.org/wiki/C_variable_types_and_declarations + + +#if USHRT_MAX >= 0xffff + //! unsigned 16 bit type + typedef unsigned short u16; + typedef short s16; +#else + #error "don't know how to typedef 'u16' on this system" +#endif + + +#if UINT_MAX >= 0xffffffff + typedef unsigned int u32; + typedef int s32; +#elif ULONG_MAX >= 0xffffffff + typedef unsigned long u32; + typedef long s32; +#else + #error "don't know how to typedef 'u32' on this system" +#endif + + +#if defined(ARMA_64BIT_WORD) + #if ULONG_MAX >= 0xffffffffffffffff + typedef unsigned long u64; + typedef long s64; + #else + #if ULLONG_MAX >= 0xffffffffffffffff + typedef unsigned long long u64; + typedef long long s64; + #else + #error "don't know how to typedef 'u64' on this system" + #endif + #endif +#endif + + + +// // only supported by C++11, via #include , or by C99, via #include +// +// typedef uint8_t u8; +// typedef int8_t s8; +// +// typedef uint16_t u16; +// typedef int16_t s16; +// +// typedef uint32_t u32; +// typedef int32_t s32; +// +// typedef uint64_t u64; +// typedef int64_t s64; + + + +#if !defined(ARMA_64BIT_WORD) + typedef u32 uword; + typedef s32 sword; + + typedef u16 uhword; + typedef s16 shword; + + #define ARMA_MAX_UWORD 0xffffffff + #define ARMA_MAX_UHWORD 0xffff +#else + typedef u64 uword; + typedef s64 sword; + + typedef u32 uhword; + typedef s32 shword; + + #define ARMA_MAX_UWORD 0xffffffffffffffff + #define ARMA_MAX_UHWORD 0xffffffff +#endif + + + +typedef std::complex cx_float; +typedef std::complex cx_double; + +typedef Mat uchar_mat; +typedef Col uchar_vec; +typedef Col uchar_colvec; +typedef Row uchar_rowvec; +typedef Cube uchar_cube; + +typedef Mat u32_mat; +typedef Col u32_vec; +typedef Col u32_colvec; +typedef Row u32_rowvec; +typedef Cube u32_cube; + +typedef Mat s32_mat; +typedef Col s32_vec; +typedef Col s32_colvec; +typedef Row s32_rowvec; +typedef Cube s32_cube; + +typedef Mat umat; +typedef Col uvec; +typedef Col ucolvec; +typedef Row urowvec; +typedef Cube ucube; + +typedef Mat imat; +typedef Col ivec; +typedef Col icolvec; +typedef Row irowvec; +typedef Cube icube; + +typedef Mat fmat; +typedef Col fvec; +typedef Col fcolvec; +typedef Row frowvec; +typedef Cube fcube; + +typedef Mat mat; +typedef Col vec; +typedef Col colvec; +typedef Row rowvec; +typedef Cube cube; + +typedef Mat cx_fmat; +typedef Col cx_fvec; +typedef Col cx_fcolvec; +typedef Row cx_frowvec; +typedef Cube cx_fcube; + +typedef Mat cx_mat; +typedef Col cx_vec; +typedef Col cx_colvec; +typedef Row cx_rowvec; +typedef Cube cx_cube; + + + +typedef void* void_ptr; + + + +namespace junk + { + struct arma_elem_size_test + { + + arma_static_check( (sizeof(u8) != 1), ERROR___TYPE_U8_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(s8) != 1), ERROR___TYPE_S8_HAS_UNSUPPORTED_SIZE ); + + arma_static_check( (sizeof(u16) != 2), ERROR___TYPE_U16_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(s16) != 2), ERROR___TYPE_S16_HAS_UNSUPPORTED_SIZE ); + + arma_static_check( (sizeof(u32) != 4), ERROR___TYPE_U32_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(s32) != 4), ERROR___TYPE_S32_HAS_UNSUPPORTED_SIZE ); + + #if defined(ARMA_64BIT_WORD) + arma_static_check( (sizeof(u64) != 8), ERROR___TYPE_U64_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(s64) != 8), ERROR___TYPE_S64_HAS_UNSUPPORTED_SIZE ); + #endif + + arma_static_check( (sizeof(float) != 4), ERROR___TYPE_FLOAT_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(double) != 8), ERROR___TYPE_DOUBLE_HAS_UNSUPPORTED_SIZE ); + + arma_static_check( (sizeof(std::complex) != 8), ERROR___TYPE_COMPLEX_FLOAT_HAS_UNSUPPORTED_SIZE ); + arma_static_check( (sizeof(std::complex) != 16), ERROR___TYPE_COMPLEX_DOUBLE_HAS_UNSUPPORTED_SIZE ); + + }; + } + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/typedef_blas_int.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/typedef_blas_int.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,27 @@ +// Copyright (C) 2011 NICTA (www.nicta.com.au) +// Copyright (C) 2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup typedef +//! @{ + + +#if defined(ARMA_BLAS_LONG_LONG) + typedef long long blas_int; +#elif defined(ARMA_BLAS_LONG) + typedef long blas_int; +#else + typedef int blas_int; +#endif + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/typedef_fixed.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/typedef_fixed.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,249 @@ +// Copyright (C) 2010 NICTA (www.nicta.com.au) +// Copyright (C) 2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup typedef_fixed +//! @{ + + + +typedef umat::fixed<2,2> umat22; +typedef umat::fixed<3,3> umat33; +typedef umat::fixed<4,4> umat44; +typedef umat::fixed<5,5> umat55; +typedef umat::fixed<6,6> umat66; +typedef umat::fixed<7,7> umat77; +typedef umat::fixed<8,8> umat88; +typedef umat::fixed<9,9> umat99; + +typedef imat::fixed<2,2> imat22; +typedef imat::fixed<3,3> imat33; +typedef imat::fixed<4,4> imat44; +typedef imat::fixed<5,5> imat55; +typedef imat::fixed<6,6> imat66; +typedef imat::fixed<7,7> imat77; +typedef imat::fixed<8,8> imat88; +typedef imat::fixed<9,9> imat99; + +typedef fmat::fixed<2,2> fmat22; +typedef fmat::fixed<3,3> fmat33; +typedef fmat::fixed<4,4> fmat44; +typedef fmat::fixed<5,5> fmat55; +typedef fmat::fixed<6,6> fmat66; +typedef fmat::fixed<7,7> fmat77; +typedef fmat::fixed<8,8> fmat88; +typedef fmat::fixed<9,9> fmat99; + +typedef mat::fixed<2,2> mat22; +typedef mat::fixed<3,3> mat33; +typedef mat::fixed<4,4> mat44; +typedef mat::fixed<5,5> mat55; +typedef mat::fixed<6,6> mat66; +typedef mat::fixed<7,7> mat77; +typedef mat::fixed<8,8> mat88; +typedef mat::fixed<9,9> mat99; + +typedef cx_fmat::fixed<2,2> cx_fmat22; +typedef cx_fmat::fixed<3,3> cx_fmat33; +typedef cx_fmat::fixed<4,4> cx_fmat44; +typedef cx_fmat::fixed<5,5> cx_fmat55; +typedef cx_fmat::fixed<6,6> cx_fmat66; +typedef cx_fmat::fixed<7,7> cx_fmat77; +typedef cx_fmat::fixed<8,8> cx_fmat88; +typedef cx_fmat::fixed<9,9> cx_fmat99; + +typedef cx_mat::fixed<2,2> cx_mat22; +typedef cx_mat::fixed<3,3> cx_mat33; +typedef cx_mat::fixed<4,4> cx_mat44; +typedef cx_mat::fixed<5,5> cx_mat55; +typedef cx_mat::fixed<6,6> cx_mat66; +typedef cx_mat::fixed<7,7> cx_mat77; +typedef cx_mat::fixed<8,8> cx_mat88; +typedef cx_mat::fixed<9,9> cx_mat99; + + +// + + +typedef uvec::fixed<2> uvec2; +typedef uvec::fixed<3> uvec3; +typedef uvec::fixed<4> uvec4; +typedef uvec::fixed<5> uvec5; +typedef uvec::fixed<6> uvec6; +typedef uvec::fixed<7> uvec7; +typedef uvec::fixed<8> uvec8; +typedef uvec::fixed<9> uvec9; + +typedef ivec::fixed<2> ivec2; +typedef ivec::fixed<3> ivec3; +typedef ivec::fixed<4> ivec4; +typedef ivec::fixed<5> ivec5; +typedef ivec::fixed<6> ivec6; +typedef ivec::fixed<7> ivec7; +typedef ivec::fixed<8> ivec8; +typedef ivec::fixed<9> ivec9; + +typedef fvec::fixed<2> fvec2; +typedef fvec::fixed<3> fvec3; +typedef fvec::fixed<4> fvec4; +typedef fvec::fixed<5> fvec5; +typedef fvec::fixed<6> fvec6; +typedef fvec::fixed<7> fvec7; +typedef fvec::fixed<8> fvec8; +typedef fvec::fixed<9> fvec9; + +typedef vec::fixed<2> vec2; +typedef vec::fixed<3> vec3; +typedef vec::fixed<4> vec4; +typedef vec::fixed<5> vec5; +typedef vec::fixed<6> vec6; +typedef vec::fixed<7> vec7; +typedef vec::fixed<8> vec8; +typedef vec::fixed<9> vec9; + +typedef cx_fvec::fixed<2> cx_fvec2; +typedef cx_fvec::fixed<3> cx_fvec3; +typedef cx_fvec::fixed<4> cx_fvec4; +typedef cx_fvec::fixed<5> cx_fvec5; +typedef cx_fvec::fixed<6> cx_fvec6; +typedef cx_fvec::fixed<7> cx_fvec7; +typedef cx_fvec::fixed<8> cx_fvec8; +typedef cx_fvec::fixed<9> cx_fvec9; + +typedef cx_vec::fixed<2> cx_vec2; +typedef cx_vec::fixed<3> cx_vec3; +typedef cx_vec::fixed<4> cx_vec4; +typedef cx_vec::fixed<5> cx_vec5; +typedef cx_vec::fixed<6> cx_vec6; +typedef cx_vec::fixed<7> cx_vec7; +typedef cx_vec::fixed<8> cx_vec8; +typedef cx_vec::fixed<9> cx_vec9; + + +// + + +typedef ucolvec::fixed<2> ucolvec2; +typedef ucolvec::fixed<3> ucolvec3; +typedef ucolvec::fixed<4> ucolvec4; +typedef ucolvec::fixed<5> ucolvec5; +typedef ucolvec::fixed<6> ucolvec6; +typedef ucolvec::fixed<7> ucolvec7; +typedef ucolvec::fixed<8> ucolvec8; +typedef ucolvec::fixed<9> ucolvec9; + +typedef icolvec::fixed<2> icolvec2; +typedef icolvec::fixed<3> icolvec3; +typedef icolvec::fixed<4> icolvec4; +typedef icolvec::fixed<5> icolvec5; +typedef icolvec::fixed<6> icolvec6; +typedef icolvec::fixed<7> icolvec7; +typedef icolvec::fixed<8> icolvec8; +typedef icolvec::fixed<9> icolvec9; + +typedef fcolvec::fixed<2> fcolvec2; +typedef fcolvec::fixed<3> fcolvec3; +typedef fcolvec::fixed<4> fcolvec4; +typedef fcolvec::fixed<5> fcolvec5; +typedef fcolvec::fixed<6> fcolvec6; +typedef fcolvec::fixed<7> fcolvec7; +typedef fcolvec::fixed<8> fcolvec8; +typedef fcolvec::fixed<9> fcolvec9; + +typedef colvec::fixed<2> colvec2; +typedef colvec::fixed<3> colvec3; +typedef colvec::fixed<4> colvec4; +typedef colvec::fixed<5> colvec5; +typedef colvec::fixed<6> colvec6; +typedef colvec::fixed<7> colvec7; +typedef colvec::fixed<8> colvec8; +typedef colvec::fixed<9> colvec9; + +typedef cx_fcolvec::fixed<2> cx_fcolvec2; +typedef cx_fcolvec::fixed<3> cx_fcolvec3; +typedef cx_fcolvec::fixed<4> cx_fcolvec4; +typedef cx_fcolvec::fixed<5> cx_fcolvec5; +typedef cx_fcolvec::fixed<6> cx_fcolvec6; +typedef cx_fcolvec::fixed<7> cx_fcolvec7; +typedef cx_fcolvec::fixed<8> cx_fcolvec8; +typedef cx_fcolvec::fixed<9> cx_fcolvec9; + +typedef cx_colvec::fixed<2> cx_colvec2; +typedef cx_colvec::fixed<3> cx_colvec3; +typedef cx_colvec::fixed<4> cx_colvec4; +typedef cx_colvec::fixed<5> cx_colvec5; +typedef cx_colvec::fixed<6> cx_colvec6; +typedef cx_colvec::fixed<7> cx_colvec7; +typedef cx_colvec::fixed<8> cx_colvec8; +typedef cx_colvec::fixed<9> cx_colvec9; + + +// + + +typedef urowvec::fixed<2> urowvec2; +typedef urowvec::fixed<3> urowvec3; +typedef urowvec::fixed<4> urowvec4; +typedef urowvec::fixed<5> urowvec5; +typedef urowvec::fixed<6> urowvec6; +typedef urowvec::fixed<7> urowvec7; +typedef urowvec::fixed<8> urowvec8; +typedef urowvec::fixed<9> urowvec9; + +typedef irowvec::fixed<2> irowvec2; +typedef irowvec::fixed<3> irowvec3; +typedef irowvec::fixed<4> irowvec4; +typedef irowvec::fixed<5> irowvec5; +typedef irowvec::fixed<6> irowvec6; +typedef irowvec::fixed<7> irowvec7; +typedef irowvec::fixed<8> irowvec8; +typedef irowvec::fixed<9> irowvec9; + +typedef frowvec::fixed<2> frowvec2; +typedef frowvec::fixed<3> frowvec3; +typedef frowvec::fixed<4> frowvec4; +typedef frowvec::fixed<5> frowvec5; +typedef frowvec::fixed<6> frowvec6; +typedef frowvec::fixed<7> frowvec7; +typedef frowvec::fixed<8> frowvec8; +typedef frowvec::fixed<9> frowvec9; + +typedef rowvec::fixed<2> rowvec2; +typedef rowvec::fixed<3> rowvec3; +typedef rowvec::fixed<4> rowvec4; +typedef rowvec::fixed<5> rowvec5; +typedef rowvec::fixed<6> rowvec6; +typedef rowvec::fixed<7> rowvec7; +typedef rowvec::fixed<8> rowvec8; +typedef rowvec::fixed<9> rowvec9; + +typedef cx_frowvec::fixed<2> cx_frowvec2; +typedef cx_frowvec::fixed<3> cx_frowvec3; +typedef cx_frowvec::fixed<4> cx_frowvec4; +typedef cx_frowvec::fixed<5> cx_frowvec5; +typedef cx_frowvec::fixed<6> cx_frowvec6; +typedef cx_frowvec::fixed<7> cx_frowvec7; +typedef cx_frowvec::fixed<8> cx_frowvec8; +typedef cx_frowvec::fixed<9> cx_frowvec9; + +typedef cx_rowvec::fixed<2> cx_rowvec2; +typedef cx_rowvec::fixed<3> cx_rowvec3; +typedef cx_rowvec::fixed<4> cx_rowvec4; +typedef cx_rowvec::fixed<5> cx_rowvec5; +typedef cx_rowvec::fixed<6> cx_rowvec6; +typedef cx_rowvec::fixed<7> cx_rowvec7; +typedef cx_rowvec::fixed<8> cx_rowvec8; +typedef cx_rowvec::fixed<9> cx_rowvec9; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/undefine_conflicts.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/undefine_conflicts.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,49 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + + +#if defined(log2) + #undef log2 + + #if defined(__GNUG__) + #warning "detected 'log2' macro and undefined it" + #elif defined(_MSC_VER) + #pragma message ("detected 'log2' macro and undefined it") + #endif +#endif + + + +// +// whoever defined macros with the names "min" and "max" should be permanently removed from the gene pool + +#if defined(min) + #undef min + + #if defined(__GNUG__) + #warning "detected 'min' macro and undefined it; you may wish to define NOMINMAX before including any windows header" + #elif defined(_MSC_VER) + #pragma message ("detected 'min' macro and undefined it; you may wish to define NOMINMAX before including any windows header") + #endif +#endif + +#if defined(max) + #undef max + + #if defined(__GNUG__) + #warning "detected 'max' macro and undefined it; you may wish to define NOMINMAX before including any windows header" + #elif defined(_MSC_VER) + #pragma message ("detected 'max' macro and undefined it; you may wish to define NOMINMAX before including any windows header") + #endif +#endif + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/unwrap.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/unwrap.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,1483 @@ +// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2011 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup unwrap +//! @{ + + + +template +class unwrap + { + public: + + typedef typename T1::elem_type eT; + + inline unwrap(const T1& A) // TODO: change this to Base ? + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Mat M; + }; + + + +template +class unwrap< Mat > + { + public: + + inline unwrap(const Mat& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Mat& M; + }; + + + +template +class unwrap< Row > + { + public: + + inline unwrap(const Row& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Row& M; + }; + + + +template +class unwrap< Col > + { + public: + + inline unwrap(const Col& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Col& M; + }; + + + +template +class unwrap< mtGlue > + { + public: + + inline unwrap(const mtGlue& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Mat M; + }; + + +template +class unwrap< mtOp > + { + public: + + inline unwrap(const mtOp& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Mat M; + }; + + + +// +// +// + + +template +class unwrap_check + { + public: + + typedef typename T1::elem_type eT; + + inline + unwrap_check(const T1& A, const Mat& B) + : M(A) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~unwrap_check() + { + arma_extra_debug_sigprint(); + } + + const Mat M; + }; + + + +template +class unwrap_check< Mat > + { + public: + + inline + unwrap_check(const Mat& A, const Mat& B) + : M_local( (&A == &B) ? new Mat(A) : 0 ) + , M ( (&A == &B) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class unwrap_check< Row > + { + public: + + inline + unwrap_check(const Row& A, const Mat& B) + : M_local( (&A == reinterpret_cast*>(&B)) ? new Row(A) : 0 ) + , M ( (&A == reinterpret_cast*>(&B)) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Row* M_local; + const Row& M; + }; + + + +template +class unwrap_check< Col > + { + public: + + inline + unwrap_check(const Col& A, const Mat& B) + : M_local( (&A == reinterpret_cast*>(&B)) ? new Col(A) : 0 ) + , M ( (&A == reinterpret_cast*>(&B)) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Col* M_local; + const Col& M; + + }; + + + +// +// +// + + + +template +class unwrap_check_mixed + { + public: + + typedef typename T1::elem_type eT1; + + template + inline + unwrap_check_mixed(const T1& A, const Mat& B) + : M(A) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~unwrap_check_mixed() + { + arma_extra_debug_sigprint(); + } + + const Mat M; + }; + + + +template +class unwrap_check_mixed< Mat > + { + public: + + template + inline + unwrap_check_mixed(const Mat& A, const Mat& B) + : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Mat(A) : 0 ) + , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check_mixed() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class unwrap_check_mixed< Row > + { + public: + + template + inline + unwrap_check_mixed(const Row& A, const Mat& B) + : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Row(A) : 0 ) + , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check_mixed() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Row* M_local; + const Row& M; + }; + + + +template +class unwrap_check_mixed< Col > + { + public: + + template + inline + unwrap_check_mixed(const Col& A, const Mat& B) + : M_local( (void_ptr(&A) == void_ptr(&B)) ? new Col(A) : 0 ) + , M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_check_mixed() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Col* M_local; + const Col& M; + }; + + + +// + + + +template +class partial_unwrap + { + public: + + typedef typename T1::elem_type eT; + + inline partial_unwrap(const T1& A) // TODO: change this to Base ? + : M(A) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + const Mat M; + }; + + + +template +class partial_unwrap< Mat > + { + public: + + inline + partial_unwrap(const Mat& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Row > + { + public: + + inline + partial_unwrap(const Row& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Col > + { + public: + + inline + partial_unwrap(const Col& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Op > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap(const Op& A) + : M(A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + const Mat M; + }; + + + +template +class partial_unwrap< Op< Mat, op_htrans> > + { + public: + + inline + partial_unwrap(const Op< Mat, op_htrans>& A) + : M(A.m) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Op< Row, op_htrans> > + { + public: + + inline + partial_unwrap(const Op< Row, op_htrans>& A) + : M(A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Op< Col, op_htrans> > + { + public: + + inline + partial_unwrap(const Op< Col, op_htrans>& A) + : M(A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + const Mat& M; + }; + + + +template +class partial_unwrap< Op > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap(const Op& A) + : val(A.aux) + , M (A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + const eT val; + const Mat M; + }; + + + +template +class partial_unwrap< Op< Mat, op_htrans2> > + { + public: + + inline + partial_unwrap(const Op< Mat, op_htrans2>& A) + : val(A.aux) + , M (A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap< Op< Row, op_htrans2> > + { + public: + + inline + partial_unwrap(const Op< Row, op_htrans2>& A) + : val(A.aux) + , M (A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap< Op< Col, op_htrans2> > + { + public: + + inline + partial_unwrap(const Op< Col, op_htrans2>& A) + : val(A.aux) + , M (A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap< eOp > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap(const eOp& A) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat M; + }; + + + +template +class partial_unwrap< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap(const eOp,eop_scalar_times>& A) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap(const eOp,eop_scalar_times>& A) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap(const eOp,eop_scalar_times>& A) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +// + + + +template +class partial_unwrap_check + { + public: + + typedef typename T1::elem_type eT; + + inline partial_unwrap_check(const T1& A, const Mat& B) + : M(A) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + const Mat M; + }; + + + +template +class partial_unwrap_check< Mat > + { + public: + + inline + partial_unwrap_check(const Mat& A, const Mat& B) + : M_local ( (&A == &B) ? new Mat(A) : 0 ) + , M ( (&A == &B) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Row > + { + public: + + inline + partial_unwrap_check(const Row& A, const Mat& B) + : M_local ( (&A == &B) ? new Mat(A) : 0 ) + , M ( (&A == &B) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Col > + { + public: + + inline + partial_unwrap_check(const Col& A, const Mat& B) + : M_local ( (&A == &B) ? new Mat(A) : 0 ) + , M ( (&A == &B) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = false; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap_check(const Op& A, const Mat& B) + : M(A.m) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + const Mat M; + }; + + + +template +class partial_unwrap_check< Op< Mat, op_htrans> > + { + public: + + inline + partial_unwrap_check(const Op< Mat, op_htrans>& A, const Mat& B) + : M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op< Row, op_htrans> > + { + public: + + inline + partial_unwrap_check(const Op< Row, op_htrans>& A, const Mat& B) + : M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op< Col, op_htrans> > + { + public: + + inline + partial_unwrap_check(const Op< Col, op_htrans>& A, const Mat& B) + : M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return eT(1); } + + + static const bool do_trans = true; + static const bool do_times = false; + + // the order below is important + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap_check(const Op& A, const Mat& B) + : val(A.aux) + , M (A.m) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + const eT val; + const Mat M; + }; + + + +template +class partial_unwrap_check< Op< Mat, op_htrans2> > + { + public: + + inline + partial_unwrap_check(const Op< Mat, op_htrans2>& A, const Mat& B) + : val (A.aux) + , M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + // the order below is important + const eT val; + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op< Row, op_htrans2> > + { + public: + + inline + partial_unwrap_check(const Op< Row, op_htrans2>& A, const Mat& B) + : val (A.aux) + , M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + // the order below is important + const eT val; + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< Op< Col, op_htrans2> > + { + public: + + inline + partial_unwrap_check(const Op< Mat, op_htrans2>& A, const Mat& B) + : val (A.aux) + , M_local ( (&A.m == &B) ? new Mat(A.m) : 0 ) + , M ( (&A.m == &B) ? (*M_local) : A.m ) + { + arma_extra_debug_sigprint(); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = true; + static const bool do_times = true; + + // the order below is important + const eT val; + const Mat* M_local; + const Mat& M; + }; + + + +template +class partial_unwrap_check< eOp > + { + public: + + typedef typename T1::elem_type eT; + + inline + partial_unwrap_check(const eOp& A, const Mat& B) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat M; + }; + + + +template +class partial_unwrap_check< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap_check(const eOp,eop_scalar_times>& A, const Mat& B) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap_check< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap_check(const eOp,eop_scalar_times>& A, const Mat& B) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +template +class partial_unwrap_check< eOp, eop_scalar_times> > + { + public: + + inline + partial_unwrap_check(const eOp,eop_scalar_times>& A, const Mat& B) + : val(A.aux) + , M (A.P.Q) + { + arma_extra_debug_sigprint(); + arma_ignore(B); + } + + inline + ~partial_unwrap_check() + { + arma_extra_debug_sigprint(); + } + + + inline eT get_val() const { return val; } + + + static const bool do_trans = false; + static const bool do_times = true; + + const eT val; + const Mat& M; + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/unwrap_cube.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/unwrap_cube.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,114 @@ +// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup unwrap_cube +//! @{ + + + +template +class unwrap_cube + { + public: + + typedef typename T1::elem_type eT; + + inline + unwrap_cube(const T1& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Cube M; + }; + + + +template +class unwrap_cube< Cube > + { + public: + + inline + unwrap_cube(const Cube& A) + : M(A) + { + arma_extra_debug_sigprint(); + } + + const Cube& M; + }; + + + +// +// +// + + + +template +class unwrap_cube_check + { + typedef typename T1::elem_type eT; + + inline + unwrap_cube_check(const T1& A, const Cube& B) + : M(A) + { + arma_extra_debug_sigprint(); + + arma_type_check(( is_arma_cube_type::value == false )); + } + + const Cube M; + }; + + + +template +class unwrap_cube_check< Cube > + { + public: + + inline + unwrap_cube_check(const Cube& A, const Cube& B) + : M_local( (&A == &B) ? new Cube(A) : 0 ) + , M ( (&A == &B) ? (*M_local) : A ) + { + arma_extra_debug_sigprint(); + } + + + inline + ~unwrap_cube_check() + { + arma_extra_debug_sigprint(); + + if(M_local) + { + delete M_local; + } + } + + + // the order below is important + const Cube* M_local; + const Cube& M; + + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/upgrade_val.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/upgrade_val.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,156 @@ +// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) +// Copyright (C) 2009-2010 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup upgrade_val +//! @{ + + + +//! upgrade_val is used to ensure an operation such as multiplication is possible between two types. +//! values are upgraded only where necessary. + +template +struct upgrade_val + { + typedef typename promote_type::result T1_result; + typedef typename promote_type::result T2_result; + + arma_inline + static + typename promote_type::result + apply(const T1 x) + { + typedef typename promote_type::result out_type; + return out_type(x); + } + + arma_inline + static + typename promote_type::result + apply(const T2 x) + { + typedef typename promote_type::result out_type; + return out_type(x); + } + + }; + + +// template<> +template +struct upgrade_val + { + typedef T T1_result; + typedef T T2_result; + + arma_inline static const T& apply(const T& x) { return x; } + }; + + +//! upgrade a type to allow multiplication with a complex type +//! e.g. the int in "int * complex" is upgraded to a double +// template<> +template +struct upgrade_val< std::complex, T2 > + { + typedef std::complex T1_result; + typedef T T2_result; + + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + arma_inline static T apply(const T2 x) { return T(x); } + }; + + +// template<> +template +struct upgrade_val< T1, std::complex > + { + typedef T T1_result; + typedef std::complex T2_result; + + arma_inline static T apply(const T1 x) { return T(x); } + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + }; + + +//! ensure we don't lose precision when multiplying a complex number with a higher precision real number +template<> +struct upgrade_val< std::complex, double > + { + typedef std::complex T1_result; + typedef double T2_result; + + arma_inline static const std::complex apply(const std::complex& x) { return std::complex(x); } + arma_inline static double apply(const double x) { return x; } + }; + + +template<> +struct upgrade_val< double, std::complex > + { + typedef double T1_result; + typedef std::complex T2_result; + + arma_inline static double apply(const double x) { return x; } + arma_inline static const std::complex apply(const std::complex& x) { return std::complex(x); } + }; + + +//! ensure we don't lose precision when multiplying complex numbers with different underlying types +template<> +struct upgrade_val< std::complex, std::complex > + { + typedef std::complex T1_result; + typedef std::complex T2_result; + + arma_inline static const std::complex apply(const std::complex& x) { return std::complex(x); } + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + }; + + +template<> +struct upgrade_val< std::complex, std::complex > + { + typedef std::complex T1_result; + typedef std::complex T2_result; + + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + arma_inline static const std::complex apply(const std::complex& x) { return std::complex(x); } + }; + + +//! work around limitations in the complex class (at least as present in gcc 4.1 & 4.3) +template<> +struct upgrade_val< std::complex, float > + { + typedef std::complex T1_result; + typedef double T2_result; + + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + arma_inline static double apply(const float x) { return double(x); } + }; + + +template<> +struct upgrade_val< float, std::complex > + { + typedef double T1_result; + typedef std::complex T2_result; + + arma_inline static double apply(const float x) { return double(x); } + arma_inline static const std::complex& apply(const std::complex& x) { return x; } + }; + + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/wall_clock_bones.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/wall_clock_bones.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,47 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup wall_clock +//! @{ + + +//! Class for measuring time intervals +class wall_clock + { + public: + + inline wall_clock(); + inline ~wall_clock(); + + inline void tic(); //!< start the timer + inline double toc(); //!< return the number of seconds since the last call to tic() + + + private: + + bool valid; + + #if defined(ARMA_USE_BOOST_DATE) + boost::posix_time::ptime boost_time1; + boost::posix_time::time_duration boost_duration; + #elif defined(ARMA_HAVE_GETTIMEOFDAY) + struct timeval posix_time1; + struct timeval posix_time2; + #else + clock_t time1; + #endif + + }; + + +//! @} diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_bits/wall_clock_meat.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_bits/wall_clock_meat.hpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,102 @@ +// Copyright (C) 2008-2012 NICTA (www.nicta.com.au) +// Copyright (C) 2008-2012 Conrad Sanderson +// +// This file is part of the Armadillo C++ library. +// It is provided without any warranty of fitness +// for any purpose. You can redistribute this file +// and/or modify it under the terms of the GNU +// Lesser General Public License (LGPL) as published +// by the Free Software Foundation, either version 3 +// of the License or (at your option) any later version. +// (see http://www.opensource.org/licenses for more info) + + +//! \addtogroup wall_clock +//! @{ + + +inline +wall_clock::wall_clock() + : valid(false) + { + arma_extra_debug_sigprint(); + } + + + +inline +wall_clock::~wall_clock() + { + arma_extra_debug_sigprint(); + } + + + +inline +void +wall_clock::tic() + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_BOOST_DATE) + { + boost_time1 = boost::posix_time::microsec_clock::local_time(); + valid = true; + } + #elif defined(ARMA_HAVE_GETTIMEOFDAY) + { + gettimeofday(&posix_time1, 0); + valid = true; + } + #else + { + time1 = clock(); + valid = true; + } + #endif + } + + + +inline +double +wall_clock::toc() + { + arma_extra_debug_sigprint(); + + if(valid) + { + #if defined(ARMA_USE_BOOST_DATE) + { + boost_duration = boost::posix_time::microsec_clock::local_time() - boost_time1; + return boost_duration.total_microseconds() * 1e-6; + } + #elif defined(ARMA_HAVE_GETTIMEOFDAY) + { + gettimeofday(&posix_time2, 0); + + const double tmp_time1 = posix_time1.tv_sec + posix_time1.tv_usec * 1.0e-6; + const double tmp_time2 = posix_time2.tv_sec + posix_time2.tv_usec * 1.0e-6; + + return tmp_time2 - tmp_time1; + } + #else + { + clock_t time2 = clock(); + + clock_t diff = time2 - time1; + + return double(diff) / double(CLOCKS_PER_SEC); + } + #endif + } + else + { + return 0.0; + } + } + + + +//! @} + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/include/armadillo_itpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/include/armadillo_itpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,14 @@ +// +// !WARNING! +// +// As IT++ 4.0 is licensed under the terms of General Public +// License (GPL) without any exception, including this file +// will necessairly cause your work to be covered by the GPL. +// If you do not wish for this to happen, do not include this +// file. + + +#define ARMA_USE_ITPP + +#include + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/index.html --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/index.html Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,10 @@ + + + + + diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/licenses/GPL.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/licenses/GPL.txt Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/licenses/LGPL.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/licenses/LGPL.txt Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff -r 000000000000 -r 8b6102e2a9b0 armadillo-2.4.4/src/wrap_libs.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/armadillo-2.4.4/src/wrap_libs.cpp Wed Apr 11 09:27:06 2012 +0100 @@ -0,0 +1,623 @@ +#include "armadillo_bits/config.hpp" +#include "armadillo_bits/typedef_blas_int.hpp" + +#undef ARMA_USE_WRAPPER +#include "armadillo_bits/compiler_setup.hpp" + +#include "armadillo_bits/undefine_conflicts.hpp" +#include "armadillo_bits/include_atlas.hpp" + + +namespace arma +{ + +#include "armadillo_bits/blas_bones.hpp" +#include "armadillo_bits/lapack_bones.hpp" + +// at this stage we have prototypes for the real blas, lapack and atlas functions + +// now we make the wrapper functions + + +extern "C" + { + #if defined(ARMA_USE_BLAS) + + float arma_fortran_prefix(arma_sdot)(blas_int* n, const float* x, blas_int* incx, const float* y, blas_int* incy) + { + return arma_fortran_noprefix(arma_sdot)(n, x, incx, y, incy); + } + + double arma_fortran_prefix(arma_ddot)(blas_int* n, const double* x, blas_int* incx, const double* y, blas_int* incy) + { + return arma_fortran_noprefix(arma_ddot)(n, x, incx, y, incy); + } + + + + void arma_fortran_prefix(arma_sgemv)(const char* transA, const blas_int* m, const blas_int* n, const float* alpha, const float* A, const blas_int* ldA, const float* x, const blas_int* incx, const float* beta, float* y, const blas_int* incy) + { + arma_fortran_noprefix(arma_sgemv)(transA, m, n, alpha, A, ldA, x, incx, beta, y, incy); + } + + void arma_fortran_prefix(arma_dgemv)(const char* transA, const blas_int* m, const blas_int* n, const double* alpha, const double* A, const blas_int* ldA, const double* x, const blas_int* incx, const double* beta, double* y, const blas_int* incy) + { + arma_fortran_noprefix(arma_dgemv)(transA, m, n, alpha, A, ldA, x, incx, beta, y, incy); + } + + void arma_fortran_prefix(arma_cgemv)(const char* transA, const blas_int* m, const blas_int* n, const void* alpha, const void* A, const blas_int* ldA, const void* x, const blas_int* incx, const void* beta, void* y, const blas_int* incy) + { + arma_fortran_noprefix(arma_cgemv)(transA, m, n, alpha, A, ldA, x, incx, beta, y, incy); + } + + void arma_fortran_prefix(arma_zgemv)(const char* transA, const blas_int* m, const blas_int* n, const void* alpha, const void* A, const blas_int* ldA, const void* x, const blas_int* incx, const void* beta, void* y, const blas_int* incy) + { + arma_fortran_noprefix(arma_zgemv)(transA, m, n, alpha, A, ldA, x, incx, beta, y, incy); + } + + + + void arma_fortran_prefix(arma_sgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const float* alpha, const float* A, const blas_int* ldA, const float* B, const blas_int* ldB, const float* beta, float* C, const blas_int* ldC) + { + arma_fortran_noprefix(arma_sgemm)(transA, transB, m, n, k, alpha, A, ldA, B, ldB, beta, C, ldC); + } + + void arma_fortran_prefix(arma_dgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const double* alpha, const double* A, const blas_int* ldA, const double* B, const blas_int* ldB, const double* beta, double* C, const blas_int* ldC) + { + arma_fortran_noprefix(arma_dgemm)(transA, transB, m, n, k, alpha, A, ldA, B, ldB, beta, C, ldC); + } + + void arma_fortran_prefix(arma_cgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const void* alpha, const void* A, const blas_int* ldA, const void* B, const blas_int* ldB, const void* beta, void* C, const blas_int* ldC) + { + arma_fortran_noprefix(arma_cgemm)(transA, transB, m, n, k, alpha, A, ldA, B, ldB, beta, C, ldC); + } + + void arma_fortran_prefix(arma_zgemm)(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const void* alpha, const void* A, const blas_int* ldA, const void* B, const blas_int* ldB, const void* beta, void* C, const blas_int* ldC) + { + arma_fortran_noprefix(arma_zgemm)(transA, transB, m, n, k, alpha, A, ldA, B, ldB, beta, C, ldC); + } + + #endif + + + + #if defined(ARMA_USE_LAPACK) + + void arma_fortran_prefix(arma_sgetrf)(blas_int* m, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, blas_int* info) + { + arma_fortran_noprefix(arma_sgetrf)(m, n, a, lda, ipiv, info); + } + + void arma_fortran_prefix(arma_dgetrf)(blas_int* m, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, blas_int* info) + { + arma_fortran_noprefix(arma_dgetrf)(m, n, a, lda, ipiv, info); + } + + void arma_fortran_prefix(arma_cgetrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, blas_int* info) + { + arma_fortran_noprefix(arma_cgetrf)(m, n, a, lda, ipiv, info); + } + + void arma_fortran_prefix(arma_zgetrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, blas_int* info) + { + arma_fortran_noprefix(arma_zgetrf)(m, n, a, lda, ipiv, info); + } + + + + void arma_fortran_prefix(arma_sgetri)(blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgetri)(n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_dgetri)(blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgetri)(n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_cgetri)(blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgetri)(n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_zgetri)(blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgetri)(n, a, lda, ipiv, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_strtri)(char* uplo, char* diag, blas_int* n, float* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_strtri)(uplo, diag, n, a, lda, info); + } + + void arma_fortran_prefix(arma_dtrtri)(char* uplo, char* diag, blas_int* n, double* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_dtrtri)(uplo, diag, n, a, lda, info); + } + + void arma_fortran_prefix(arma_ctrtri)(char* uplo, char* diag, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_ctrtri)(uplo, diag, n, a, lda, info); + } + + void arma_fortran_prefix(arma_ztrtri)(char* uplo, char* diag, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_ztrtri)(uplo, diag, n, a, lda, info); + } + + + + void arma_fortran_prefix(arma_ssyev)(char* jobz, char* uplo, blas_int* n, float* a, blas_int* lda, float* w, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_ssyev)(jobz, uplo, n, a, lda, w, work, lwork, info); + } + + void arma_fortran_prefix(arma_dsyev)(char* jobz, char* uplo, blas_int* n, double* a, blas_int* lda, double* w, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dsyev)(jobz, uplo, n, a, lda, w, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_cheev)(char* jobz, char* uplo, blas_int* n, void* a, blas_int* lda, float* w, void* work, blas_int* lwork, float* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_cheev)(jobz, uplo, n, a, lda, w, work, lwork, rwork, info); + } + + void arma_fortran_prefix(arma_zheev)(char* jobz, char* uplo, blas_int* n, void* a, blas_int* lda, double* w, void* work, blas_int* lwork, double* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_zheev)(jobz, uplo, n, a, lda, w, work, lwork, rwork, info); + } + + + + void arma_fortran_prefix(arma_sgeev)(char* jobvl, char* jobvr, blas_int* n, float* a, blas_int* lda, float* wr, float* wi, float* vl, blas_int* ldvl, float* vr, blas_int* ldvr, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgeev)(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info); + } + + void arma_fortran_prefix(arma_dgeev)(char* jobvl, char* jobvr, blas_int* n, double* a, blas_int* lda, double* wr, double* wi, double* vl, blas_int* ldvl, double* vr, blas_int* ldvr, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgeev)(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_cgeev)(char* jobvl, char* jobvr, blas_int* n, void* a, blas_int* lda, void* w, void* vl, blas_int* ldvl, void* vr, blas_int* ldvr, void* work, blas_int* lwork, float* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgeev)(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info); + } + + void arma_fortran_prefix(arma_zgeev)(char* jobvl, char* jobvr, blas_int* n, void* a, blas_int* lda, void* w, void* vl, blas_int* ldvl, void* vr, blas_int* ldvr, void* work, blas_int* lwork, double* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgeev)(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info); + } + + + + void arma_fortran_prefix(arma_spotrf)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_spotrf)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_dpotrf)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_dpotrf)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_cpotrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_cpotrf)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_zpotrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_zpotrf)(uplo, n, a, lda, info); + } + + + + void arma_fortran_prefix(arma_spotri)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_spotri)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_dpotri)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_dpotri)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_cpotri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_cpotri)(uplo, n, a, lda, info); + } + + void arma_fortran_prefix(arma_zpotri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* info) + { + arma_fortran_noprefix(arma_zpotri)(uplo, n, a, lda, info); + } + + + + void arma_fortran_prefix(arma_sgeqrf)(blas_int* m, blas_int* n, float* a, blas_int* lda, float* tau, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgeqrf)(m, n, a, lda, tau, work, lwork, info); + } + + void arma_fortran_prefix(arma_dgeqrf)(blas_int* m, blas_int* n, double* a, blas_int* lda, double* tau, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgeqrf)(m, n, a, lda, tau, work, lwork, info); + } + + void arma_fortran_prefix(arma_cgeqrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgeqrf)(m, n, a, lda, tau, work, lwork, info); + } + + void arma_fortran_prefix(arma_zgeqrf)(blas_int* m, blas_int* n, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgeqrf)(m, n, a, lda, tau, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_sorgqr)(blas_int* m, blas_int* n, blas_int* k, float* a, blas_int* lda, float* tau, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sorgqr)(m, n, k, a, lda, tau, work, lwork, info); + } + + void arma_fortran_prefix(arma_dorgqr)(blas_int* m, blas_int* n, blas_int* k, double* a, blas_int* lda, double* tau, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dorgqr)(m, n, k, a, lda, tau, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_cungqr)(blas_int* m, blas_int* n, blas_int* k, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_cungqr)(m, n, k, a, lda, tau, work, lwork, info); + } + + void arma_fortran_prefix(arma_zungqr)(blas_int* m, blas_int* n, blas_int* k, void* a, blas_int* lda, void* tau, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_zungqr)(m, n, k, a, lda, tau, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_sgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, float* a, blas_int* lda, float* s, float* u, blas_int* ldu, float* vt, blas_int* ldvt, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgesvd)(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info); + } + + void arma_fortran_prefix(arma_dgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, double* a, blas_int* lda, double* s, double* u, blas_int* ldu, double* vt, blas_int* ldvt, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgesvd)(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info); + } + + + + void arma_fortran_prefix(arma_cgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, void* a, blas_int* lda, float* s, void* u, blas_int* ldu, void* vt, blas_int* ldvt, void* work, blas_int* lwork, float* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgesvd)(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info); + } + + void arma_fortran_prefix(arma_zgesvd)(char* jobu, char* jobvt, blas_int* m, blas_int* n, void* a, blas_int* lda, double* s, void* u, blas_int* ldu, void* vt, blas_int* ldvt, void* work, blas_int* lwork, double* rwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgesvd)(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info); + } + + + + void arma_fortran_prefix(arma_sgesv)(blas_int* n, blas_int* nrhs, float* a, blas_int* lda, blas_int* ipiv, float* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_sgesv)(n, nrhs, a, lda, ipiv, b, ldb, info); + } + + void arma_fortran_prefix(arma_dgesv)(blas_int* n, blas_int* nrhs, double* a, blas_int* lda, blas_int* ipiv, double* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_dgesv)(n, nrhs, a, lda, ipiv, b, ldb, info); + } + + void arma_fortran_prefix(arma_cgesv)(blas_int* n, blas_int* nrhs, void* a, blas_int* lda, blas_int* ipiv, void* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_cgesv)(n, nrhs, a, lda, ipiv, b, ldb, info); + } + + void arma_fortran_prefix(arma_zgesv)(blas_int* n, blas_int* nrhs, void* a, blas_int* lda, blas_int* ipiv, void* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_zgesv)(n, nrhs, a, lda, ipiv, b, ldb, info); + } + + + + void arma_fortran_prefix(arma_sgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, float* a, blas_int* lda, float* b, blas_int* ldb, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgels)(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info); + } + + void arma_fortran_prefix(arma_dgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, double* a, blas_int* lda, double* b, blas_int* ldb, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgels)(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info); + } + + void arma_fortran_prefix(arma_cgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, void* a, blas_int* lda, void* b, blas_int* ldb, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgels)(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info); + } + + void arma_fortran_prefix(arma_zgels)(char* trans, blas_int* m, blas_int* n, blas_int* nrhs, void* a, blas_int* lda, void* b, blas_int* ldb, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgels)(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info); + } + + + + + void arma_fortran_prefix(arma_strtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const float* a, blas_int* lda, float* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_strtrs)(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info); + } + + void arma_fortran_prefix(arma_dtrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const double* a, blas_int* lda, double* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_dtrtrs)(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info); + } + + void arma_fortran_prefix(arma_ctrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const void* a, blas_int* lda, void* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_ctrtrs)(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info); + } + + void arma_fortran_prefix(arma_ztrtrs)(char* uplo, char* trans, char* diag, blas_int* n, blas_int* nrhs, const void* a, blas_int* lda, void* b, blas_int* ldb, blas_int* info) + { + arma_fortran_noprefix(arma_ztrtrs)(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info); + } + + + + + void arma_fortran_prefix(arma_sgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, float* a, blas_int* lda, blas_int* sdim, float* wr, float* wi, float* vs, blas_int* ldvs, float* work, blas_int* lwork, blas_int* bwork, blas_int* info) + { + arma_fortran_noprefix(arma_sgees)(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info); + } + + void arma_fortran_prefix(arma_dgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, double* a, blas_int* lda, blas_int* sdim, double* wr, double* wi, double* vs, blas_int* ldvs, double* work, blas_int* lwork, blas_int* bwork, blas_int* info) + { + arma_fortran_noprefix(arma_dgees)(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info); + } + + + + void arma_fortran_prefix(arma_cgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, void* a, blas_int* lda, blas_int* sdim, void* w, void* vs, blas_int* ldvs, void* work, blas_int* lwork, float* rwork, blas_int* bwork, blas_int* info) + { + arma_fortran_noprefix(arma_cgees)(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info); + } + + void arma_fortran_prefix(arma_zgees)(char* jobvs, char* sort, blas_int* select, blas_int* n, void* a, blas_int* lda, blas_int* sdim, void* w, void* vs, blas_int* ldvs, void* work, blas_int* lwork, double* rwork, blas_int* bwork, blas_int* info) + { + arma_fortran_noprefix(arma_zgees)(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info); + } + + + + void arma_fortran_prefix(arma_strsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const float* a, blas_int* lda, const float* b, blas_int* ldb, float* c, blas_int* ldc, float* scale, blas_int* info) + { + arma_fortran_noprefix(arma_strsyl)(transa, transb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info); + } + + void arma_fortran_prefix(arma_dtrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const double* a, blas_int* lda, const double* b, blas_int* ldb, double* c, blas_int* ldc, double* scale, blas_int* info) + { + arma_fortran_noprefix(arma_dtrsyl)(transa, transb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info); + } + + void arma_fortran_prefix(arma_ctrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const void* a, blas_int* lda, const void* b, blas_int* ldb, void* c, blas_int* ldc, float* scale, blas_int* info) + { + arma_fortran_noprefix(arma_ctrsyl)(transa, transb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info); + } + + void arma_fortran_prefix(arma_ztrsyl)(char* transa, char* transb, blas_int* isgn, blas_int* m, blas_int* n, const void* a, blas_int* lda, const void* b, blas_int* ldb, void* c, blas_int* ldc, double* scale, blas_int* info) + { + arma_fortran_noprefix(arma_ztrsyl)(transa, transb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info); + } + + + + + void arma_fortran_prefix(arma_ssytrf)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_ssytrf)(uplo, n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_dsytrf)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_dsytrf)(uplo, n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_csytrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_csytrf)(uplo, n, a, lda, ipiv, work, lwork, info); + } + + void arma_fortran_prefix(arma_zsytrf)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* lwork, blas_int* info) + { + arma_fortran_noprefix(arma_zsytrf)(uplo, n, a, lda, ipiv, work, lwork, info); + } + + + + + void arma_fortran_prefix(arma_ssytri)(char* uplo, blas_int* n, float* a, blas_int* lda, blas_int* ipiv, float* work, blas_int* info) + { + arma_fortran_noprefix(arma_ssytri)(uplo, n, a, lda, ipiv, work, info); + } + + void arma_fortran_prefix(arma_dsytri)(char* uplo, blas_int* n, double* a, blas_int* lda, blas_int* ipiv, double* work, blas_int* info) + { + arma_fortran_noprefix(arma_dsytri)(uplo, n, a, lda, ipiv, work, info); + } + + void arma_fortran_prefix(arma_csytri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* info) + { + arma_fortran_noprefix(arma_csytri)(uplo, n, a, lda, ipiv, work, info); + } + + void arma_fortran_prefix(arma_zsytri)(char* uplo, blas_int* n, void* a, blas_int* lda, blas_int* ipiv, void* work, blas_int* info) + { + arma_fortran_noprefix(arma_zsytri)(uplo, n, a, lda, ipiv, work, info); + } + + #endif + + + + #if defined(ARMA_USE_ATLAS) + + float wrapper_cblas_sdot(const int N, const float *X, const int incX, const float *Y, const int incY) + { + return cblas_sdot(N, X, incX, Y, incY); + } + + double wrapper_cblas_ddot(const int N, const double *X, const int incX, const double *Y, const int incY) + { + return cblas_ddot(N, X, incX, Y, incY); + } + + void wrapper_cblas_cdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu) + { + cblas_cdotu_sub(N, X, incX, Y, incY, dotu); + } + + void wrapper_cblas_zdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu) + { + cblas_zdotu_sub(N, X, incX, Y, incY, dotu); + } + + + + void wrapper_cblas_sgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const float alpha, + const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY) + { + cblas_sgemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); + } + + void wrapper_cblas_dgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const double alpha, + const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY) + { + cblas_dgemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); + } + + void wrapper_cblas_cgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, + const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY) + { + cblas_cgemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); + } + + void wrapper_cblas_zgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, + const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY) + { + cblas_zgemv(Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); + } + + + + void wrapper_cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const float alpha, + const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc) + { + cblas_sgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); + } + + void wrapper_cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const double alpha, + const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc) + { + cblas_dgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); + } + + void wrapper_cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const void *alpha, + const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc) + { + cblas_cgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); + } + + void wrapper_cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, + const int M, const int N, const int K, const void *alpha, + const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc) + { + cblas_zgemm(Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); + } + + + + int wrapper_clapack_sgetrf(const enum CBLAS_ORDER Order, const int M, const int N, float *A, const int lda, int *ipiv) + { + return clapack_sgetrf(Order, M, N, A, lda, ipiv); + } + + int wrapper_clapack_dgetrf(const enum CBLAS_ORDER Order, const int M, const int N, double *A, const int lda, int *ipiv) + { + return clapack_dgetrf(Order, M, N, A, lda, ipiv); + } + + int wrapper_clapack_cgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv) + { + return clapack_cgetrf(Order, M, N, A, lda, ipiv); + } + + int wrapper_clapack_zgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv) + { + return clapack_zgetrf(Order, M, N, A, lda, ipiv); + } + + + + int wrapper_clapack_sgetri(const enum CBLAS_ORDER Order, const int N, float *A, const int lda, const int *ipiv) + { + return clapack_sgetri(Order, N, A, lda, ipiv); + } + + int wrapper_clapack_dgetri(const enum CBLAS_ORDER Order, const int N, double *A, const int lda, const int *ipiv) + { + return clapack_dgetri(Order, N, A, lda, ipiv); + } + + int wrapper_clapack_cgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv) + { + return clapack_cgetri(Order, N, A, lda, ipiv); + } + + int wrapper_clapack_zgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv) + { + return clapack_zgetri(Order, N, A, lda, ipiv); + } + + + + int wrapper_clapack_sgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, float *A, const int lda, int *ipiv, float *B, const int ldb) + { + return clapack_sgesv(Order, N, NRHS, A, lda, ipiv, B, ldb); + } + + int wrapper_clapack_dgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, double *A, const int lda, int *ipiv, double *B, const int ldb) + { + return clapack_dgesv(Order, N, NRHS, A, lda, ipiv, B, ldb); + } + + int wrapper_clapack_cgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb) + { + return clapack_cgesv(Order, N, NRHS, A, lda, ipiv, B, ldb); + } + + int wrapper_clapack_zgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb) + { + return clapack_zgesv(Order, N, NRHS, A, lda, ipiv, B, ldb); + } + + #endif + } + +}