├── .config.mk.ci.clang
├── .config.mk.ci.gcc
├── .config.mk.ci.gcc.nocheck
├── .gitignore
├── .gitlab-ci.yml
├── ChangeLog.md
├── LICENSE
├── Makefile
├── README.md
├── VERSION
├── benchmark.cxx
├── config.mk.default
├── doc
    ├── Makefile
    ├── doxygen
    │   ├── Doxyfile
    │   ├── DoxygenLayout.xml
    │   ├── footer.html
    │   ├── header.html
    │   ├── mainpage.md
    │   ├── stylesheet.css
    │   ├── xerus.png
    │   └── xerus.svg
    └── jekyll
    │   ├── .gitignore
    │   ├── _config.yml
    │   ├── _includes
    │       ├── examples
    │       │   ├── als.cpp
    │       │   ├── als.py
    │       │   ├── cascade.cpp
    │       │   ├── cascade.gnuplot
    │       │   ├── cascade.py
    │       │   ├── qtt.cpp
    │       │   └── qtt.py
    │       ├── footer.html
    │       ├── header.html
    │       ├── sidebar-content.html
    │       ├── sidebar.html
    │       └── version.svp
    │   ├── _layouts
    │       └── post.html
    │   ├── _plugins
    │       └── tabs.rb
    │   ├── _posts
    │       ├── 1000-10-10-cascade.md
    │       ├── 1000-11-10-minimal_als.md
    │       ├── 1000-12-10-quickstart.md
    │       ├── 2000-10-20-debugging.md
    │       ├── 2000-10-25-optimization.md
    │       ├── 2000-11-16-tensornetworks.md
    │       ├── 2000-11-18-riemannian.md
    │       ├── 2000-11-20-completion.md
    │       ├── 2000-11-22-als.md
    │       ├── 2000-11-24-tttensors.md
    │       ├── 2000-11-26-decompositions.md
    │       ├── 2000-11-28-indices.md
    │       ├── 2000-11-30-tensor.md
    │       ├── 2000-12-15-nomenclature.md
    │       └── 2000-12-20-building_xerus.md
    │   ├── css
    │       ├── bootstrap-theme.css
    │       ├── bootstrap-theme.css.map
    │       ├── bootstrap-theme.min.css
    │       ├── bootstrap-theme.min.css.map
    │       ├── bootstrap.css
    │       ├── bootstrap.css.map
    │       ├── bootstrap.min.css
    │       ├── bootstrap.min.css.map
    │       ├── footer.css
    │       ├── syntax.css
    │       ├── tabs.css
    │       └── theme.css
    │   ├── documentation.md
    │   ├── examples.md
    │   ├── fonts
    │       ├── glyphicons-halflings-regular.eot
    │       ├── glyphicons-halflings-regular.svg
    │       ├── glyphicons-halflings-regular.ttf
    │       ├── glyphicons-halflings-regular.woff
    │       └── glyphicons-halflings-regular.woff2
    │   ├── images
    │       ├── cascade.png
    │       ├── xerus.png
    │       └── xerus.svg
    │   ├── index.md
    │   └── js
    │       ├── bootstrap.js
    │       ├── bootstrap.min.js
    │       ├── jquery.min.js
    │       └── npm.js
├── include
    ├── xerus.h
    └── xerus
    │   ├── 3rdParty
    │       └── lapack.h
    │   ├── algorithms
    │       ├── adf.h
    │       ├── als.h
    │       ├── cg.h
    │       ├── decompositionAls.h
    │       ├── iht.h
    │       ├── largestEntry.h
    │       ├── randomSVD.h
    │       ├── retractions.h
    │       ├── steepestDescent.h
    │       └── uqAdf.h
    │   ├── basic.h
    │   ├── blasLapackWrapper.h
    │   ├── cholmod_wrapper.h
    │   ├── contractionHeuristic.h
    │   ├── examples
    │       ├── specificLowRankTensors.h
    │       └── tensorCompletion.h
    │   ├── index.h
    │   ├── indexedTensor.h
    │   ├── indexedTensorList.h
    │   ├── indexedTensorMoveable.h
    │   ├── indexedTensorReadOnly.h
    │   ├── indexedTensorWritable.h
    │   ├── indexedTensor_tensor_factorisations.h
    │   ├── measurments.h
    │   ├── misc.h
    │   ├── misc
    │       ├── allocator.h
    │       ├── basicArraySupport.h
    │       ├── callStack.h
    │       ├── check.h
    │       ├── containerOutput.h
    │       ├── containerSupport.h
    │       ├── exceptions.h
    │       ├── fileIO.h
    │       ├── histogram.h
    │       ├── internal.h
    │       ├── math.h
    │       ├── missingFunctions.h
    │       ├── namedLogger.h
    │       ├── performanceAnalysis.h
    │       ├── random.h
    │       ├── sfinae.h
    │       ├── simpleNumerics.h
    │       ├── sort.h
    │       ├── standard.h
    │       ├── stringFromTo.h
    │       ├── stringUtilities.h
    │       └── timeMeasure.h
    │   ├── performanceData.h
    │   ├── sparseTimesFullContraction.h
    │   ├── tensor.h
    │   ├── tensorLogger.h
    │   ├── tensorNetwork.h
    │   ├── test
    │       └── test.h
    │   ├── ttNetwork.h
    │   └── ttStack.h
├── makeIncludes
    ├── general.mk
    ├── optimization.mk
    └── warnings.mk
└── src
    ├── docHelper
        ├── findDoxytag.cpp
        └── parseDoxytags.cpp
    ├── unitTests
        ├── als.cxx
        ├── cg.cxx
        ├── consistency.cxx
        ├── decompositionAls.cxx
        ├── fileIO.cxx
        ├── fullTensor_add_sub.cxx
        ├── fullTensor_arithmetic.cxx
        ├── fullTensor_assignment.cxx
        ├── fullTensor_factor.cxx
        ├── fullTensor_factorisations.cxx
        ├── fullTensor_product.cxx
        ├── fullTensor_solve.cxx
        ├── fullTensor_sparseTensor_interaction.cxx
        ├── fullTensor_trace.cxx
        ├── fullTensor_utilities.cxx
        ├── indices.cxx
        ├── largestEntry.cxx
        ├── misc.cxx
        ├── retractions.cxx
        ├── saveAndLoad.cxx
        ├── sparseTensor.cxx
        ├── sparseTensor_add_sub_cpy.cxx
        ├── sparseTensor_arithmetic_cpy.cxx
        ├── sparseTensor_assignment.cxx
        ├── sparseTensor_assignment_cpy.cxx
        ├── sparseTensor_product_cpy.cxx
        ├── sparseTensor_trace_cpy.cxx
        ├── sparseTensor_utilities.cxx
        ├── steepestDescent.cxx
        ├── strassen.cxx
        ├── tensor.cxx
        ├── tensorNetwork.cxx
        ├── tensorNetwork_element_access.cxx
        ├── tensors.cxx
        ├── ttArithmetic.cxx
        ├── ttCompletion.cxx
        ├── ttCreation.cxx
        ├── ttOther.cxx
        ├── ttRounding.cxx
        ├── tutorials.cxx
        └── xPerformanceAnalysis.cxx
    └── xerus
        ├── algorithms
            ├── adf.cpp
            ├── als.cpp
            ├── cg.cpp
            ├── decompositionAls.cpp
            ├── iht.cpp
            ├── largestEntry.cpp
            ├── retractions.cpp
            ├── steepestDescent.cpp
            └── uqAdf.cpp
        ├── basic.cpp
        ├── blasLapackWrapper.cpp
        ├── cholmod_wrapper.cpp
        ├── contractionHeuristic.cpp
        ├── examples
            ├── specificLowRankTensors.cpp
            └── tensorCompletion.cpp
        ├── index.cpp
        ├── indexedTensor.cpp
        ├── indexedTensorList.cpp
        ├── indexedTensorMoveable.cpp
        ├── indexedTensorReadOnly.cpp
        ├── indexedTensorWritable.cpp
        ├── indexedTensor_tensor_evaluate.cpp
        ├── indexedTensor_tensor_factorisations.cpp
        ├── indexedTensor_tensor_solve.cpp
        ├── link.cpp
        ├── measurments.cpp
        ├── misc
            ├── allocator.cpp
            ├── callStack.cpp
            ├── exceptions.cpp
            ├── histogram.cpp
            ├── missingFunctions.cpp
            ├── namedLogger.cpp
            ├── performanceAnalysis.cpp
            ├── random.cpp
            ├── simpleNumerics.cpp
            ├── standard.cpp
            ├── stringUtilities.cpp
            └── timeMeasure.cpp
        ├── performanceData.cpp
        ├── python
            ├── factorizations.cpp
            ├── indexedTensor.cpp
            ├── leastSquares.cpp
            ├── misc.cpp
            ├── misc.h
            ├── python.cpp
            ├── recovery.cpp
            ├── tensor.cpp
            ├── tensorNetwork.cpp
            ├── ttnetwork.cpp
            └── vectorAndPair.h
        ├── sparseTimesFullContraction.cpp
        ├── tensor.cpp
        ├── tensorNetwork.cpp
        ├── tensorNode.cpp
        ├── tensor_specializations.cpp
        ├── test
            └── test.cpp
        ├── ttNetwork.cpp
        └── ttStack.cpp


/.config.mk.ci.clang:
--------------------------------------------------------------------------------
 1 | #=================================================================================================
 2 | # Compiler Options
 3 | #=================================================================================================
 4 | CXX = clang++
 5 | 
 6 |  DEBUG += -g                # Adds debug symbols
 7 | 
 8 | LOGGING += -D XERUS_LOG_INFO                     # Information that is not linked to any unexpected behaviour but might 
 9 | 
10 | #=================================================================================================
11 | # External libraries
12 | #=================================================================================================
13 | STRICT_WARNINGS = TRUE
14 | 
15 | # Uncomment or add the appropriate blas libraries 
16 | BLAS_LIBRARIES = -lopenblas -lgfortran                    # Openblas, serial
17 | 
18 | # Uncomment or add the appropriate lapack libraries 
19 | LAPACK_LIBRARIES = -llapacke -llapack                     # Standard Lapack + Lapacke libraries
20 | 
21 | # Uncomment or add the appropriate CXSparse library
22 | SUITESPARSE = -lcholmod -lspqr
23 | 
24 | 
25 | # custom include paths
26 | # OTHER += -I /path/to/include
27 | 
28 | 


--------------------------------------------------------------------------------
/.config.mk.ci.gcc:
--------------------------------------------------------------------------------
 1 | #=================================================================================================
 2 | # Compiler Options
 3 | #=================================================================================================
 4 | CXX = g++
 5 | 
 6 | STRICT_WARNINGS = TRUE
 7 | DEBUG += -D XERUS_TEST_COVERAGE                 # Enable coverage tests
 8 | 
 9 |  DEBUG += -g                # Adds debug symbols
10 | 
11 | #=================================================================================================
12 | # External libraries
13 | #=================================================================================================
14 | BLAS_LIBRARIES = -lopenblas -lgfortran                    # Openblas, serial
15 | LAPACK_LIBRARIES = -llapacke -llapack                     # Standard Lapack + Lapacke libraries
16 | SUITESPARSE = -lcholmod  -lspqr
17 | 
18 | OTHER += -I /usr/include/python2.7/ -lboost_python -I/usr/lib64/python2.7/site-packages/numpy/core/include/ -lpython2.7 -fno-var-tracking-assignments
19 | 


--------------------------------------------------------------------------------
/.config.mk.ci.gcc.nocheck:
--------------------------------------------------------------------------------
 1 | #=================================================================================================
 2 | # Compiler Options
 3 | #=================================================================================================
 4 | CXX = g++
 5 | 
 6 | STRICT_WARNINGS = TRUE
 7 | 
 8 | # HIGH_OPTIMIZATION = TRUE          # Activates -O3 -march=native and some others
 9 | DEBUG += -D XERUS_DISABLE_RUNTIME_CHECKS    # Disable all runtime checks
10 | DEBUG += -D XERUS_REPLACE_ALLOCATOR
11 | 
12 |  DEBUG += -g                # Adds debug symbols
13 | 
14 | 
15 | LOGGING += -D XERUS_LOG_INFO                     # Information that is not linked to any unexpected behaviour bu
16 | 
17 | #=================================================================================================
18 | # External libraries
19 | #=================================================================================================
20 | BLAS_LIBRARIES = -lopenblas -lgfortran                    # Openblas, serial
21 | LAPACK_LIBRARIES = -llapacke -llapack                     # Standard Lapack + Lapacke libraries
22 | SUITESPARSE = -lcholmod -lspqr
23 | 
24 | 
25 | # custom include paths
26 | # OTHER += -I /path/to/include
27 | 
28 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Ignore everything
 2 | *
 3 | 
 4 | # But not these files...
 5 | !.gitignore
 6 | !*.h
 7 | !*.hpp
 8 | !*.hxx
 9 | 
10 | !*.c
11 | !*.cpp
12 | !*.cxx
13 | 
14 | !*.mk
15 | !Makefile
16 | !.gitignore
17 | 
18 | !*.sh
19 | 
20 | !*.rb
21 | !*.py
22 | 
23 | !*.md
24 | !*.xml
25 | !*.dox
26 | !*.css
27 | !*.js
28 | !*.yml
29 | 
30 | # ...even if they are in subdirectories
31 | !*/
32 | 
33 | # However we really want to ignore
34 | lapacke/*
35 | build/*
36 | doc/html/*
37 | config.mk
38 | 


--------------------------------------------------------------------------------
/.gitlab-ci.yml:
--------------------------------------------------------------------------------
 1 | stages:
 2 | - build_homepage
 3 | - build_gcc
 4 | - test_gcc
 5 | - build_gcc_nocheck
 6 | - test_gcc_nocheck
 7 | - build_python
 8 | - build_clang
 9 | - test_clang
10 | 
11 | job_build_homepage:
12 |   stage: build_homepage
13 |   script: "cp .config.mk.ci.gcc config.mk; make -C doc doc; scp -r doc/html xerusweb:libxerus.org-443"
14 |   when: always
15 |   only: 
16 |     - master
17 |   allow_failure: true
18 | 
19 | job_make_gcc:
20 |   stage: build_gcc
21 |   script: "g++ --version; cp .config.mk.ci.gcc config.mk; make XerusTest; cp XerusTest ../"
22 |   when: always
23 | 
24 | job_test_gcc:
25 |   stage: test_gcc
26 |   script: "cp ../XerusTest .; ./XerusTest all"
27 | 
28 | job_make_gcc_nocheck:
29 |   stage: build_gcc_nocheck
30 |   script: "g++ --version; cp .config.mk.ci.gcc.nocheck config.mk; make XerusTest; cp XerusTest ../"
31 | 
32 | job_test_gcc_nocheck:
33 |   stage: test_gcc_nocheck
34 |   script: "cp ../XerusTest .; ./XerusTest all"
35 | 
36 | job_build_python:
37 |   stage: build_python
38 |   script: "g++ --version; cp .config.mk.ci.gcc config.mk; make python"
39 |   when: always
40 | 
41 | job_make_clang:
42 |   stage: build_clang
43 |   script: "clang++ --version; cp .config.mk.ci.clang config.mk; make XerusTest; cp XerusTest ../"
44 |   when: always
45 | 
46 | job_test_clang:
47 |   stage: test_clang
48 |   script: "cp ../XerusTest .; ./XerusTest all"
49 | 
50 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # About #
 2 | 
 3 | The `xerus` library is a general purpose library for numerical calculations with higher order tensors, Tensor-Train Decompositions / Matrix Product States and other Tensor Networks.
 4 | The focus of development was the simple usability and adaptibility to any setting that requires higher order tensors or decompositions thereof. 
 5 | 
 6 | For tutorials and a documentation see <a href="http://libxerus.org">the documentation</a>.
 7 | 
 8 | The source code is licenced under the AGPL v3.0. For more details see the LICENSE file.
 9 | 
10 | 
11 | # Features #
12 | 
13 | + Intuitive notation for expressions involving tensors of arbitrary degree: `A(i,j) = B(i,k,l) * C(k,j,l)`;
14 | + Lazy evaluation of tensor expressions with automatically optimized contraction orders.
15 | + Full implementation of all common functionality of the Tensor Train (or Matrix Product State) decompositions with either dense or sparse component tensors.
16 | + Implementations of common algorithms like the ALS, (multi-site-)DMRG, ASD, AFD, CG, and some less common ones e.g. to find the maximal entries in a Tensor Train.
17 | 
18 | 
19 | # Building the Xerus library #
20 | 
21 | Copy the default configuration and modify it for your needs
22 | > cp config.mk.default config.mk
23 | 
24 | > nano config.mk
25 | 
26 | Test whether everything works correctly with
27 | > make test -j4
28 | 
29 | build (and optionally install) the library with
30 | > make all -j4
31 | 
32 | > sudo make install
33 | 
34 | and you should be ready to use the library. For more details see <a href="https://www.libxerus.org/building_xerus/">the "Building Xerus" page in the documentation</a>.
35 | 
36 | 
37 | # Issues #
38 | 
39 | Should you have any problems with the library do not hesitate to contact us at contact[at]libxerus.org or describe your problem in the issuetracker.
40 | 
41 | 


--------------------------------------------------------------------------------
/VERSION:
--------------------------------------------------------------------------------
1 | 3.0.1
2 | 


--------------------------------------------------------------------------------
/doc/Makefile:
--------------------------------------------------------------------------------
 1 | # ------------------------------------------------------------------------------------------------------
 2 | #				Default rule should be the help message
 3 | # ------------------------------------------------------------------------------------------------------
 4 | help:
 5 | 	@printf "Possible make targets are:\n \
 6 | 	\t\thelp \t\t -- Print this help.\n \
 7 | 	\t\tdoc \t\t -- Build the html documentation for the xerus library.\n \
 8 | 	\t\tserve \t\t -- Build the html documentation for the xerus library and offer it via 'jekyll serve'.\n \
 9 | 	\t\tclean \t\t -- Remove all documentation files.\n"
10 | 
11 | .FORCE:
12 | doc: .FORCE parseDoxytags findDoxytag
13 | 	-mkdir html
14 | 	doxygen doxygen/Doxyfile
15 | 	./parseDoxytags
16 | 	jekyll build --source jekyll/ --destination html/
17 | 
18 | clean:
19 | 	-rm -rf html
20 | 	-rm -f parseDoxytags findDoxytag
21 | 	-rm -f xerus.tags xerus.tagfile
22 | 
23 | serve: .FORCE parseDoxytags findDoxytag
24 | 	-mkdir html
25 | 	doxygen doxygen/Doxyfile
26 | 	./parseDoxytags
27 | 	jekyll serve --source jekyll/ --destination html/
28 | 
29 | include ../config.mk
30 | include ../makeIncludes/general.mk
31 | include ../makeIncludes/warnings.mk
32 | include ../makeIncludes/optimization.mk
33 | 
34 | FLAGS = $(strip $(WARNINGS) $(OPTIMIZE) $(OTHER))
35 | 
36 | parseDoxytags: ../src/docHelper/parseDoxytags.cpp
37 | 	$(CXX) $(FLAGS) ../src/docHelper/parseDoxytags.cpp -o parseDoxytags
38 | 
39 | 
40 | findDoxytag: ../src/docHelper/findDoxytag.cpp
41 | 	$(CXX) $(FLAGS) ../src/docHelper/findDoxytag.cpp -o findDoxytag
42 | 


--------------------------------------------------------------------------------
/doc/doxygen/footer.html:
--------------------------------------------------------------------------------
 1 | <!-- HTML footer for doxygen 1.8.9.1-->
 2 | <!-- start footer part -->
 3 | <!--BEGIN GENERATE_TREEVIEW-->
 4 | <div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
 5 |   <ul>
 6 |     $navpath
 7 |     <li class="footer">$generatedby
 8 |     Doxygen $doxygenversion </li>
 9 |   </ul>
10 | </div>
11 | <!--END GENERATE_TREEVIEW-->
12 | <!--BEGIN !GENERATE_TREEVIEW-->
13 | <hr class="footer"/><address class="footer"><small>
14 | $generatedby &#160;<a href="http://www.doxygen.org/index.html">
15 | <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
16 | </a> $doxygenversion
17 | </small></address>
18 | <!--END !GENERATE_TREEVIEW-->
19 | </body>
20 | </html>
21 | 


--------------------------------------------------------------------------------
/doc/doxygen/header.html:
--------------------------------------------------------------------------------
 1 | <!-- HTML header for doxygen 1.8.9.1-->
 2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 3 | <html xmlns="http://www.w3.org/1999/xhtml">
 4 | <head>
 5 | <meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
 6 | <meta http-equiv="X-UA-Compatible" content="IE=9"/>
 7 | <meta name="generator" content="Doxygen $doxygenversion"/>
 8 | <!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
 9 | <!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
10 | <link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
11 | <script type="text/javascript" src="$relpath^jquery.js"></script>
12 | <script type="text/javascript" src="$relpath^dynsections.js"></script>
13 | $treeview
14 | $search
15 | $mathjax
16 | <link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
17 | $extrastylesheet
18 | <link rel="icon" type="image/png" href="/xerus.png" />
19 | </head>
20 | <body>
21 | <div id="top"><!-- do not remove this div, it is closed by doxygen! -->
22 | 
23 | <!--BEGIN TITLEAREA-->
24 | <div id="titlearea">
25 | <table cellspacing="0" cellpadding="0">
26 |  <tbody>
27 |  <tr style="height: 56px;">
28 |   <!--BEGIN PROJECT_LOGO-->
29 |   <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
30 |   <!--END PROJECT_LOGO-->
31 |   <!--BEGIN PROJECT_NAME-->
32 |   <td style="padding-left: 0.5em;">
33 |    <div id="projectname">$projectname
34 |    <!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
35 |    </div>
36 |    <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
37 |   </td>
38 |   <!--END PROJECT_NAME-->
39 |   <!--BEGIN !PROJECT_NAME-->
40 |    <!--BEGIN PROJECT_BRIEF-->
41 |     <td style="padding-left: 0.5em;">
42 |     <div id="projectbrief">$projectbrief</div>
43 |     </td>
44 |    <!--END PROJECT_BRIEF-->
45 |   <!--END !PROJECT_NAME-->
46 |   <!--BEGIN DISABLE_INDEX-->
47 |    <!--BEGIN SEARCHENGINE-->
48 |    <td>$searchbox</td>
49 |    <!--END SEARCHENGINE-->
50 |   <!--END DISABLE_INDEX-->
51 |  </tr>
52 |  </tbody>
53 | </table>
54 | </div>
55 | <!--END TITLEAREA-->
56 | <!-- end header part -->
57 | 


--------------------------------------------------------------------------------
/doc/doxygen/mainpage.md:
--------------------------------------------------------------------------------
 1 | # xerus - a general purpose tensor library    {#mainpage}
 2 | 
 3 | ## Doxygen Documentation
 4 | 
 5 | This is the (automatically generated) Doxygen documentation for the `xerus` library. It is the only complete documentation (ie.
 6 | mentioning all classes and functions with at least a one-line description) but far less accessible than the documents of the
 7 | [main documentation](/documentation.html) or even the [examples](/examples.html).
 8 | 
 9 | It is advisable to use a modern IDE when working with any c++ source code, but in particular when using the `xerus` library. In 
10 | which case all of the information of this documentation should also be available from within your IDE as mouse-over text or similar.
11 | If your IDE does not provide this functionality consider switching to `kdevelop`, `clion` or a similarly advanced IDE.
12 | 


--------------------------------------------------------------------------------
/doc/doxygen/xerus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/doxygen/xerus.png


--------------------------------------------------------------------------------
/doc/jekyll/.gitignore:
--------------------------------------------------------------------------------
1 | _site
2 | 
3 | 


--------------------------------------------------------------------------------
/doc/jekyll/_config.yml:
--------------------------------------------------------------------------------
 1 | # Jekyll configuration
 2 | 
 3 | name: Xerus Documentation
 4 | description: Documentation for the xerus library.
 5 | 
 6 | # baseurl will often be '', but for a project page on gh-pages, it needs to
 7 | # be the project name.
 8 | # *** IMPORTANT: If your local "jekyll serve" throws errors change this to '' or
 9 | #     run it like so: jekyll serve --baseurl=''
10 | baseurl: ''
11 | 
12 | permalink: /:title/
13 | # paginate: 3
14 | 
15 | highlighter: rouge
16 | # highlighter: coderay
17 | markdown: kramdown
18 | # gems: ['TabsConverter']
19 | 
20 | # exclude: ['README.md', 'LICENSE']
21 | keep_files: ['doxygen']
22 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/examples/als.py:
--------------------------------------------------------------------------------
  1 | import xerus as xe
  2 | 
  3 | class InternalSolver :
  4 | 	def __init__(self, A, x, b):
  5 | 		self.A = A
  6 | 		self.b = b
  7 | 		self.x = x
  8 | 		self.d = x.degree()
  9 | 		self.solutionsNorm = b.frob_norm()
 10 | 		
 11 | 		self.leftAStack = [ xe.Tensor.ones([1,1,1]) ]
 12 | 		self.leftBStack = [ xe.Tensor.ones([1,1]) ]
 13 | 		self.rightAStack = [ xe.Tensor.ones([1,1,1]) ]
 14 | 		self.rightBStack = [ xe.Tensor.ones([1,1]) ]
 15 | 		
 16 | 		self.maxIterations = 1000
 17 | 	
 18 | 	
 19 | 	def push_left_stack(self, pos) :
 20 | 		i1,i2,i3, j1,j2,j3, k1,k2 = xe.indices(8)
 21 | 		Ai = self.A.get_component(pos)
 22 | 		xi = self.x.get_component(pos)
 23 | 		bi = self.b.get_component(pos)
 24 | 		
 25 | 		tmpA = xe.Tensor()
 26 | 		tmpB = xe.Tensor()
 27 | 		tmpA(i1, i2, i3) << self.leftAStack[-1](j1, j2, j3)\
 28 | 				*xi(j1, k1, i1)*Ai(j2, k1, k2, i2)*xi(j3, k2, i3)
 29 | 		self.leftAStack.append(tmpA)
 30 | 		tmpB(i1, i2) << self.leftBStack[-1](j1, j2)\
 31 | 				*xi(j1, k1, i1)*bi(j2, k1, i2)
 32 | 		self.leftBStack.append(tmpB)
 33 | 	
 34 | 	def push_right_stack(self, pos) :
 35 | 		i1,i2,i3, j1,j2,j3, k1,k2 = xe.indices(8)
 36 | 		Ai = self.A.get_component(pos)
 37 | 		xi = self.x.get_component(pos)
 38 | 		bi = self.b.get_component(pos)
 39 | 		
 40 | 		tmpA = xe.Tensor()
 41 | 		tmpB = xe.Tensor()
 42 | 		tmpA(j1, j2, j3) << xi(j1, k1, i1)*Ai(j2, k1, k2, i2)*xi(j3, k2, i3) \
 43 | 				* self.rightAStack[-1](i1, i2, i3)
 44 | 		self.rightAStack.append(tmpA)
 45 | 		tmpB(j1, j2) << xi(j1, k1, i1)*bi(j2, k1, i2) \
 46 | 				* self.rightBStack[-1](i1, i2)
 47 | 		self.rightBStack.append(tmpB)
 48 | 	
 49 | 	
 50 | 	def calc_residual_norm(self) :
 51 | 		i,j = xe.indices(2)
 52 | 		return xe.frob_norm(self.A(i/2, j/2)*self.x(j&0) - self.b(i&0)) / self.solutionsNorm
 53 | 	
 54 | 	
 55 | 	def solve(self) :
 56 | 		# build right stack
 57 | 		self.x.move_core(0, True)
 58 | 		for pos in reversed(xrange(1, self.d)) :
 59 | 			self.push_right_stack(pos)
 60 | 		
 61 | 		i1,i2,i3, j1,j2,j3, k1,k2 = xe.indices(8)
 62 | 		residuals = [1000]*10
 63 | 		
 64 | 		for itr in xrange(self.maxIterations) :
 65 | 			residuals.append(self.calc_residual_norm())
 66 | 			if residuals[-1]/residuals[-10] > 0.99 :
 67 | 				print("Done! Residual decreased from:", residuals[10], "to", residuals[-1], "in", len(residuals)-10, "sweeps")
 68 | 				return
 69 | 			
 70 | 			print("Iteration:",itr, "Residual:", residuals[-1])
 71 | 			
 72 | 			# sweep left -> right
 73 | 			for pos in xrange(self.d):
 74 | 				op = xe.Tensor()
 75 | 				rhs = xe.Tensor()
 76 | 				
 77 | 				Ai = self.A.get_component(pos)
 78 | 				bi = self.b.get_component(pos)
 79 | 				
 80 | 				op(i1, i2, i3, j1, j2, j3) << self.leftAStack[-1](i1, k1, j1)*Ai(k1, i2, j2, k2)*self.rightAStack[-1](i3, k2, j3)
 81 | 				rhs(i1, i2, i3) <<            self.leftBStack[-1](i1, k1) *   bi(k1, i2, k2) *   self.rightBStack[-1](i3, k2)
 82 | 				
 83 | 				tmp = xe.Tensor()
 84 | 				tmp(i1&0) << rhs(j1&0) / op(j1/2, i1/2)
 85 | 				self.x.set_component(pos, tmp)
 86 | 				
 87 | 				if pos+1 < self.d :
 88 | 					self.x.move_core(pos+1, True)
 89 | 					self.push_left_stack(pos)
 90 | 					self.rightAStack.pop()
 91 | 					self.rightBStack.pop()
 92 | 			
 93 | 			
 94 | 			# right -> left, only move core and update stack
 95 | 			self.x.move_core(0, True)
 96 | 			for pos in reversed(xrange(1,self.d)) :
 97 | 				self.push_right_stack(pos)
 98 | 				self.leftAStack.pop()
 99 | 				self.leftBStack.pop()
100 | 
101 | 
102 | def simpleALS(A, x, b) :
103 | 	solver = InternalSolver(A, x, b)
104 | 	solver.solve()
105 | 
106 | if __name__ == "__main__":
107 | 	i,j,k = xe.indices(3)
108 | 	
109 | 	A = xe.TTOperator.random([4]*16, [2]*7)
110 | 	A(i/2,j/2) << A(i/2, k/2) * A(j/2, k/2)
111 | 	
112 | 	solution = xe.TTTensor.random([4]*8, [3]*7)
113 | 	b = xe.TTTensor()
114 | 	b(i&0) << A(i/2, j/2) * solution(j&0)
115 | 	
116 | 	x = xe.TTTensor.random([4]*8, [3]*7)
117 | 	simpleALS(A, x, b)
118 | 	
119 | 	print("Residual:", xe.frob_norm(A(i/2, j/2) * x(j&0) - b(i&0))/xe.frob_norm(b))
120 | 	print("Error:", xe.frob_norm(solution-x)/xe.frob_norm(x))
121 | 	
122 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/examples/cascade.gnuplot:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/gnuplot
 2 | 
 3 | set term pngcairo size 600, 400
 4 | unset key
 5 | set grid
 6 | set output "cascade.png"
 7 | set xlabel "timestep"
 8 | set ylabel "mean concentration"
 9 | 
10 | plot 'mean.dat' u 1 w l, \
11 |      'mean.dat' u 2 w l, \
12 |      'mean.dat' u 3 w l, \
13 |      'mean.dat' u 4 w l, \
14 |      'mean.dat' u 5 w l, \
15 |      'mean.dat' u 6 w l, \
16 |      'mean.dat' u 7 w l, \
17 |      'mean.dat' u 8 w l, \
18 |      'mean.dat' u 9 w l, \
19 |      'mean.dat' u 10 w l
20 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/examples/qtt.cpp:
--------------------------------------------------------------------------------
 1 | #include <xerus.h>
 2 | 
 3 | int main() {
 4 | 	// construct the stiffness matrix A using a lambda function
 5 | 	// and dividing it by h^2 = multiplying it with N^2
 6 | 	xerus::Tensor A({512,512}, [](const std::vector<size_t> &idx){
 7 | 		if (idx[0] == idx[1]) {
 8 | 			return 2.0;
 9 | 		} else if (idx[1] == idx[0]+1 || idx[1]+1 == idx[0]) {
10 | 			return -1.0;
11 | 		} else {
12 | 			return 0.0;
13 | 		}
14 | 	});
15 | 	
16 | 	A *= 512*512;
17 | 	
18 | 	// reinterpret the 512x512 tensor as a 2^18 tensor
19 | 	// and create (Q)TT decomposition of it
20 | 	A.reinterpret_dimensions(std::vector<size_t>(18, 2));
21 | 	xerus::TTOperator ttA(A);
22 | 	
23 | 	// and verify its rank
24 | 	using xerus::misc::operator<<;
25 | 	std::cout << "ttA ranks: " << ttA.ranks() << std::endl;
26 | 	
27 | 	// the right hand side of the equation both as Tensor and in (Q)TT format
28 | 	auto b = xerus::Tensor::ones(std::vector<size_t>(9, 2));
29 | 	auto ttb = xerus::TTTensor::ones(b.dimensions);
30 | 	
31 | 	// construct a random initial guess of rank 3 for the ALS algorithm
32 | 	xerus::TTTensor ttx = xerus::TTTensor::random(std::vector<size_t>(9, 2), std::vector<size_t>(8, 3));
33 | 	
34 | 	// and solve the system with the default ALS algorithm for symmetric positive operators
35 | 	xerus::ALS_SPD(ttA, ttx, ttb);
36 | 	
37 | 	// to perform arithmetic operations we need to define some indices
38 | 	xerus::Index i,j,k;
39 | 	
40 | 	// calculate the residual of the just solved system to evaluate its accuracy
41 | 	// here i^9 denotes a multiindex named i of dimension 9 (ie. spanning 9 indices of the respective tensors)
42 | 	double residual = frob_norm( ttA(i^9,j^9)*ttx(j^9) - ttb(i^9) );
43 | 	std::cout << "residual: " << residual << std::endl;
44 | 	
45 | 	// as an comparison solve the system exactly using the Tensor / operator
46 | 	xerus::Tensor x;
47 | 	x(j^9) = b(i^9) / A(i^9, j^9);
48 | 	
49 | 	// and calculate the Frobenius norm of the difference
50 | 	std::cout << "error: " << frob_norm(x - xerus::Tensor(ttx)) << std::endl;
51 | }
52 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/examples/qtt.py:
--------------------------------------------------------------------------------
 1 | import xerus as xe
 2 | 
 3 | # construct the stiffness matrix A using a fill function
 4 | def A_fill(idx):
 5 | 	if idx[0] == idx[1] :
 6 | 		return 2.0
 7 | 	elif idx[1] == idx[0]+1 or idx[1]+1 == idx[0] :
 8 | 		return -1.0
 9 | 	else:
10 | 		return 0.0
11 | 
12 | A = xe.Tensor.from_function([512,512], A_fill)
13 | 
14 | # and dividing it by h^2 = multiplying it with N^2
15 | A *= 512*512
16 | 
17 | # reinterpret the 512x512 tensor as a 2^18 tensor
18 | # and create (Q)TT decomposition of it
19 | A.reinterpret_dimensions([2,]*18)
20 | ttA = xe.TTOperator(A)
21 | 
22 | # and verify its rank
23 | print("ttA ranks:", ttA.ranks())
24 | 
25 | # the right hand side of the equation both as Tensor and in (Q)TT format
26 | b = xe.Tensor.ones([2,]*9)
27 | ttb = xe.TTTensor.ones(b.dimensions)
28 | 
29 | # construct a random initial guess of rank 3 for the ALS algorithm
30 | ttx = xe.TTTensor.random([2,]*9, [3,]*8)
31 | 
32 | # and solve the system with the default ALS algorithm for symmetric positive operators
33 | xe.ALS_SPD(ttA, ttx, ttb)
34 | 
35 | # to perform arithmetic operations we need to define some indices
36 | i,j,k = xe.indices(3)
37 | 
38 | # calculate the residual of the just solved system to evaluate its accuracy
39 | # here i^9 denotes a multiindex named i of dimension 9 (ie. spanning 9 indices of the respective tensors)
40 | residual = xe.frob_norm( ttA(i^9,j^9)*ttx(j^9) - ttb(i^9) )
41 | print("residual:", residual)
42 | 
43 | # as an comparison solve the system exactly using the Tensor / operator
44 | x = xe.Tensor()
45 | x(j^9) << b(i^9) / A(i^9, j^9)
46 | 
47 | # and calculate the Frobenius norm of the difference
48 | print("error:", xe.frob_norm(x - xe.Tensor(ttx)))
49 | 
50 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/footer.html:
--------------------------------------------------------------------------------
 1 | <div class="container-fluid">
 2 |     <div class="row-fluid">
 3 |         <div class="visible-sm visible-xs span12 footer navbar-inverse navbar-fixed-bottom">
 4 |           <div class="pagination">
 5 |               {% if page.next %}
 6 |                 <a class="btn btn-default" href="{{ site.baseurl}}{{ page.next.url }}" class="previous"><span class="glyphicon glyphicon-chevron-left"></span></a>
 7 |               {% else %}
 8 |                 <a class="btn btn-default disabled" href="#" class="previous"><span class="glyphicon glyphicon-chevron-left"></span></a>
 9 |               {% endif %}
10 |               
11 |                 <div class="btn btn-default footer-menu" tabindex="0"><span class="glyphicon glyphicon-list"></span></div>
12 |                 <div class="footer-menu-content well">
13 |                 {% include sidebar-content.html %}
14 |                 </div>
15 |                 
16 |                 
17 |               {% if page.previous %}
18 |                 <a class="btn btn-default" href="{{ site.baseurl}}{{ page.previous.url }}" class="next"><span class="glyphicon glyphicon-chevron-right"></span></a>
19 |               {% else %}
20 |                 <a class="btn btn-default disabled" href="#" class="next"><span class="glyphicon glyphicon-chevron-right"></span></a>
21 |               {% endif %}
22 |           </div>
23 | 
24 |         </div>
25 |     </div>
26 | </div>
27 | 
28 | </body>
29 | </html>
30 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/header.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |     <title>Xerus Documentation{% if page.title %} - {{ page.title }} {% endif %}</title>
 6 |     <link rel="icon" href="{{ site.baseurl }}/images/xerus.png">
 7 |     <meta charset="UTF-8">
 8 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 9 |     <script src="{{ site.baseurl }}/js/jquery.min.js"></script>
10 |     <script src="{{ site.baseurl }}/js/bootstrap.min.js"></script>
11 |     <link href="{{ site.baseurl }}/css/bootstrap.min.css" rel="stylesheet" type="text/css">
12 |     <link href="{{ site.baseurl }}/css/theme.css" rel="stylesheet" type="text/css">
13 |     <link href="{{ site.baseurl }}/css/syntax.css" rel="stylesheet" type="text/css">
14 |     <link href="{{ site.baseurl }}/css/tabs.css" rel="stylesheet" type="text/css">
15 |     <link href="{{ site.baseurl }}/css/footer.css" rel="stylesheet" type="text/css">
16 |     <script type="text/x-mathjax-config">
17 | 	  MathJax.Hub.Config({tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}});
18 | 	</script>
19 |     <script type="text/javascript" async src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-MML-AM_CHTML"></script>
20 | </head>
21 | 
22 | <body>
23 | 
24 | <header class="navbar navbar-inverse navbar-fixed-top docs-nav" role="banner">
25 |   <div class="container">
26 |     <div class="navbar-header">
27 |       <button class="navbar-toggle" type="button" data-toggle="collapse" data-target=".bs-navbar-collapse">
28 |         <span class="sr-only">Toggle navigation</span>
29 |         <span class="icon-bar"></span>
30 |         <span class="icon-bar"></span>
31 |         <span class="icon-bar"></span>
32 |       </button>
33 |       <a class="navbar-brand" href="{{ site.baseurl }}/">Xerus</a>
34 |     </div>
35 |     <nav class="collapse navbar-collapse bs-navbar-collapse" role="navigation">
36 |       <ul class="nav navbar-nav">
37 |           {% if page.section == "Documentation" %}
38 |                     <li class="active"><a href="{{ site.baseurl }}/documentation/">Documentation</a></li>
39 |           {% else %}
40 |                     <li><a href="{{ site.baseurl }}/documentation/">Documentation</a></li>
41 |           {% endif %}
42 |           {% if page.section == "Examples" %}
43 |                     <li class="active"><a href="{{ site.baseurl }}/examples/">Examples</a></li>
44 |           {% else %}
45 |                     <li><a href="{{ site.baseurl }}/examples/">Examples</a></li>
46 |           {% endif %}
47 |       </ul>
48 |       <ul class="nav navbar-nav navbar-right">
49 |                     <li><a href="https://git.hemio.de/xerus/xerus">Git</a></li>
50 |                     <li><a href="https://github.com/libxerus/xerus">Github</a></li>
51 |                     <li><a href="https://git.hemio.de/xerus/xerus/issues">Issue-Tracker</a></li>
52 |                 </ul>
53 |     </nav>
54 |   </div>
55 | </header>
56 | 
57 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/sidebar-content.html:
--------------------------------------------------------------------------------
 1 | {% for post in site.posts %}
 2 |   {% if post.section == page.section %}
 3 |     {% unless post.next %}
 4 |             <h1>{{ post.topic }}</h1>
 5 |             <ul>
 6 |     {% else %}
 7 |         {% capture topic %}{{ post.topic }}{% endcapture %}
 8 |         {% capture ntopic %}{{ post.next.topic }}{% endcapture %}
 9 |         {% if topic != ntopic %}
10 |             </ul>
11 |             <h1>{{ post.topic }}</h1>
12 |             <ul>
13 |         {% endif %}
14 |     {% endunless %}
15 |     {% if post.url == page.url %}
16 |     	<li>{{ post.title }}</li>
17 |     {% else %}
18 |     	<li><a href="{{ site.baseurl}}{{ post.url }}">{{ post.title }}</a></li>
19 |     {% endif %}
20 |   {% endif %}
21 | {% endfor %}
22 | </ul>
23 | {% if page.section == "Documentation" %}
24 |      <a href="{{ site.baseurl }}/doxygen/">Doxygen Documentation</a>
25 | {% elsif page.section == "Examples" %}
26 | 
27 | {% else %}
28 |      <a href="{{ site.baseurl }}/documentation/"><h1>Documentation</h1></a>
29 |      <a href="{{ site.baseurl }}/examples/"><h1>Examples</h1></a>
30 |      <a href="https://git.hemio.de/xerus/xerus/"><h1>Git</h1></a>
31 |      <a href="https://git.hemio.de/xerus/xerus/issues"><h1>Issue-Tracker</h1></a>
32 |      <a href="mailto:contact@libxerus.org"><h1>Contact</h1></a>
33 | {% endif %}
34 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/sidebar.html:
--------------------------------------------------------------------------------
 1 | <div class="row">
 2 | <div class="hidden-md-down">
 3 | <center><img src="{{ site.baseurl }}/images/xerus.svg" alt="Logo" width="50%" /></center>
 4 | </div>
 5 | 
 6 | <div class="hidden-md-down well">
 7 | {% include sidebar-content.html %}
 8 | </div>
 9 | 
10 | </div>
11 | 


--------------------------------------------------------------------------------
/doc/jekyll/_includes/version.svp:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="98" height="20" style="vertical-align: middle;">  <linearGradient id="b" x2="0" y2="100%">    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>    <stop offset="1" stop-opacity=".1"/>  </linearGradient>  <mask id="a">    <rect width="98" height="20" rx="3" fill="#fff"/>  </mask>  <g mask="url(#a)">    <path fill="#555"  d="M0 0 h55 v20 H0 z"/>    <path fill="#5af"          d="M55 0 h43 v20 H55 z"/>    <path fill="url(#b)"          d="M0 0 h98 v20 H0 z"/>  </g>  <g fill="#fff" text-anchor="middle">    <g font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11"  alignment-baseline="baseline">      <text x="28" y="15" fill="#010101" fill-opacity=".3">        version      </text>      <text x="28" y="14">        version      </text>      <text x="77" y="15" fill="#010101" fill-opacity=".3">        __version      </text>      <text x="77" y="14">        __version      </text>    </g>  </g></svg>
2 | 


--------------------------------------------------------------------------------
/doc/jekyll/_layouts/post.html:
--------------------------------------------------------------------------------
 1 | {% include header.html %}
 2 | 
 3 | <div class="container">
 4 |     <div class="row">
 5 |         <div class="col-md-3 hidden-sm hidden-xs">
 6 |             {% include sidebar.html %}
 7 |         </div>
 8 |         <div class="col-md-9">
 9 |           <div class="article">
10 |             <div class="post-content">
11 |             {{ content }}
12 |             </div>
13 |           </div>
14 |         </div>
15 |     </div>
16 | </div>
17 | 
18 | {% include footer.html %}
19 | 


--------------------------------------------------------------------------------
/doc/jekyll/_plugins/tabs.rb:
--------------------------------------------------------------------------------
 1 | module Jekyll
 2 | class TabsConverter < Converter
 3 | 	safe true
 4 | 	priority :low
 5 | 
 6 | 	def matches(ext)
 7 | 		ext =~ /^\.md$/i
 8 | 	end
 9 | 
10 | 	def output_ext(ext)
11 | 		".html"
12 | 	end
13 | 
14 | 	def convert(content)
15 | 	content.gsub('<p>__tabsInit</p>', "<input id=\"tab1\" type=\"radio\" name=\"tabs\" checked><input id=\"tab2\" type=\"radio\" name=\"tabs\">")
16 | 			.gsub('<p>__tabsStart</p>', "<div id=\"tabs\"><label for=\"tab1\">C++</label><label for=\"tab2\">Python</label><div id=\"content\"><section id=\"content1\">")
17 | 			.gsub('<p>__tabsMid</p>', "</section><section id=\"content2\">")
18 | 			.gsub('<p>__tabsEnd</p>', "</section></div></div>")
19 | 			.gsub('<p>__dangerStart</p>', "<div class=\"alert alert-danger\">")
20 | 			.gsub('<p>__dangerEnd</p>', "</div>")
21 | 			.gsub('<p>__warnStart</p>', "<div class=\"alert alert-warning\">")
22 | 			.gsub('<p>__warnEnd</p>', "</div>")
23 | 			.gsub('<p>__infoStart</p>', "<div class=\"alert alert-info\">")
24 | 			.gsub('<p>__infoEnd</p>', "</div>")
25 | 			.gsub('__breakFix1</a></p>', "")
26 | 			.gsub('<p>__breakFix2', "</a>")
27 | 			.gsub('__version', %x( cat ../VERSION ) )
28 | 			.gsub(/__doxyref\(([^\)]+)\)/){ |m| %x( ./findDoxytag #{$1} ) }
29 | 	end
30 | end
31 | end
32 | 
33 | 


--------------------------------------------------------------------------------
/doc/jekyll/_posts/2000-11-16-tensornetworks.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | title: "General Tensor Networks"
 4 | date: 2000-10-30
 5 | topic: "Advanced Usage"
 6 | section: "Documentation"
 7 | ---
 8 | __tabsInit
 9 | # General Tensor Networks
10 | 
11 | __warnStart
12 | 
13 | This Chapter is still **work in progress**.
14 | Currently missing are sections on:
15 | * creating TN
16 | * constraints
17 | * (full) contractions
18 | * nodes and links
19 | * round_edge, move_core
20 | * fix_mode, remove_slate, resize_mode
21 | * sanitize
22 | 
23 | __warnEnd
24 | 


--------------------------------------------------------------------------------
/doc/jekyll/_posts/2000-11-18-riemannian.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | title: "Riemannian Algorithms"
 4 | date: 2000-11-18
 5 | topic: "Basic Usage"
 6 | section: "Documentation"
 7 | ---
 8 | __tabsInit
 9 | # TTTangentVectors and Riemannian Algorithms
10 | 
11 | __warnStart
12 | 
13 | This Chapter is still **work in progress**.
14 | Currently missing are sections on:
15 | * using steepestDescent and CG
16 | * creating TTTangentVectors
17 | * retractions
18 | * vector transport
19 | 
20 | __warnEnd
21 | 


--------------------------------------------------------------------------------
/doc/jekyll/_posts/2000-11-20-completion.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | title: "Tensor Completion / Recovery"
 4 | date: 2000-11-20
 5 | topic: "Basic Usage"
 6 | section: "Documentation"
 7 | ---
 8 | __tabsInit
 9 | # Algorithms for Tensor Competion and Recovery
10 | 
11 | __warnStart
12 | 
13 | This Chapter is still **work in progress**.
14 | Currently missing are sections on:
15 | * Singlepoint and rankOneMeasurementSets
16 | * using IHT and ADF to solve completion / recovery problems
17 | 
18 | 
19 | __warnEnd
20 | 


--------------------------------------------------------------------------------
/doc/jekyll/_posts/2000-11-22-als.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | title: "Alternating Algorithms"
 4 | date: 2000-11-22
 5 | topic: "Basic Usage"
 6 | section: "Documentation"
 7 | ---
 8 | __tabsInit
 9 | # Alternating Algorithms and Performance Data
10 | 
11 | __warnStart
12 | 
13 | This Chapter is still **work in progress**.
14 | Currently missing are sections on:
15 | * introduction to alternating algorithms
16 | * usind ALS(_SPD), ASD, DMRG to solve least squares problems
17 | * changing algorithm options via new algorithm objects
18 | * using PerformanceData to log and / or output the progress of an algorithm
19 | * defining own local solvers
20 | 
21 | __warnEnd
22 | 


--------------------------------------------------------------------------------
/doc/jekyll/css/footer.css:
--------------------------------------------------------------------------------
 1 | .footer-menu {
 2 |     /* position: relative; */
 3 |     display: inline-block;
 4 | }
 5 | .footer-menu:focus {
 6 |     /* clicking on label should toggle the menu */
 7 |     pointer-events: none;
 8 | }
 9 | .footer-menu:focus + .footer-menu-content {
10 |     /*  opacity is 1 in opened state (see below) */
11 |     opacity: 1;
12 |     visibility: visible;
13 | 
14 |     /* don't let pointer-events affect descendant elements */
15 |     pointer-events: auto;
16 | }
17 | .footer-menu-content {
18 |     position: fixed;
19 | 	top: 0;
20 | 	left: 0;
21 | 	bottom: 0;
22 | 	right: 0;
23 |     z-index: -10000;
24 | 	text-align: left;
25 | 
26 |     /* use opacity to fake immediate toggle */
27 |     opacity: 0;
28 |     visibility: hidden;
29 |     transition: visibility 0.5s;
30 | }
31 | 
32 | .navbar-header {
33 | 	z-index: 10;
34 | }
35 | .navbar-footer {
36 | 	z-index: 10;
37 | }
38 | 


--------------------------------------------------------------------------------
/doc/jekyll/css/tabs.css:
--------------------------------------------------------------------------------
  1 | #tabs {
  2 |     margin: 0 auto;
  3 |     width: 100%;  /* Ancho del contenedor */
  4 | }
  5 | 
  6 | input {
  7 | 	height: 0;
  8 | 	visibility: hidden;
  9 | 	margin: 0;
 10 | }
 11 | 
 12 | #tabs label {
 13 | 	background: #f9f9f9;  /* Fondo de las pestañas */
 14 | 	border-radius: .25em .25em 0 0;
 15 | 	color: #888;  /* Color del texto de las pestañas */
 16 | 	cursor: pointer;
 17 | 	display: block;
 18 | 	float: left;
 19 | 	font-size: 1em;  /* Tamaño del texto de las pestañas */
 20 | 	height: 2.5em;
 21 | 	line-height: 2.5em;
 22 | 	margin-right: .25em;
 23 | 	padding: 0 1.5em;
 24 | 	margin-bottom: 0; 
 25 | 	text-align: center;
 26 | }
 27 | 
 28 | 
 29 | #tabs label:hover label:active {
 30 | 	background: #ddd;  /* Fondo de las pestañas al pasar el cursor por encima */
 31 | 	color: #666;  /* Color del texto de las pestañas al pasar el cursor por encima */
 32 | }
 33 | 
 34 | input:checked + label {
 35 | 	position: relative;
 36 | 	z-index: 6;
 37 | }
 38 | 
 39 | #content {
 40 | 	display: flex;
 41 | 	flex-direction: column;
 42 | 	min-height: 2em;
 43 | 	background: #f1f1f1;  /* Fondo del contenido */
 44 | 	border-radius: 0 .25em .25em .25em;
 45 | 	padding: 0;
 46 | 	position: relative;
 47 | 	width: 100%;
 48 | 	z-index: 5;
 49 | 	margin-bottom: .25em;
 50 | }
 51 | 
 52 | #content section {
 53 | 	opacity: 0;
 54 | 	padding: 0.5em;
 55 | 	position: absolute;
 56 | 	z-index: -100;
 57 | }
 58 | 
 59 | .highlighter-rouge {
 60 | 	overflow-x: auto;
 61 | }
 62 | 
 63 | .highlighter-rouge pre {
 64 |     min-width: 662px;
 65 | 	tab-size: 4;
 66 | }
 67 | 
 68 | #content #content1 {
 69 |     position: relative;
 70 | }
 71 | 
 72 | #content #content2 {
 73 | 	width: 100%;
 74 | }
 75 | 
 76 | input#tab1:checked ~ #tabs #content #content1,
 77 | input#tab2:checked ~ #tabs #content #content2 {
 78 |     opacity: 1;
 79 |     z-index: 100;
 80 | }
 81 | 
 82 | input#tab1:checked ~ #tabs label[for=tab1] {
 83 | 	background: #f1f1f1;
 84 | 	color: #444;    
 85 | }
 86 | 
 87 | input#tab2:checked ~ #tabs label[for=tab2] {
 88 | 	background: #f1f1f1;
 89 | 	color: #444;    
 90 | }
 91 | 
 92 | input#tab1:checked ~ div #tabs #content #content1,
 93 | input#tab2:checked ~ div #tabs #content #content2 {
 94 |     opacity: 1;
 95 |     z-index: 100;
 96 | }
 97 | 
 98 | input#tab1:checked ~ div #tabs label[for=tab1] {
 99 | 	background: #f1f1f1;
100 | 	color: #444;    
101 | }
102 | 
103 | input#tab2:checked ~ div #tabs label[for=tab2] {
104 | 	background: #f1f1f1;
105 | 	color: #444;    
106 | }
107 | 


--------------------------------------------------------------------------------
/doc/jekyll/css/theme.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     padding-top: 60px;
 3 |     padding-bottom: 60px;
 4 | }
 5 | 
 6 | .copyright {
 7 |     color: #ffffff;
 8 | }
 9 | 
10 | .footer {
11 |     text-align: center;
12 | }
13 | 
14 | .footer a {
15 |     color: #ee4444;
16 | }
17 | 
18 | .sidebar h1 {
19 |     color: #ee4444;
20 |     font-size: 1.3em;
21 | }
22 | 
23 | .sidebar a {
24 |     color: #428bca;
25 | }
26 | 
27 | .sidebar li {
28 |     margin-top: .7em;
29 |     line-height: 1em;
30 | }
31 | 
32 | .sidebar a:hover {
33 |     color: #3071a9;
34 | }
35 | 
36 | .container-left {
37 |     margin: 0;
38 | }
39 | 
40 | .well h1 {
41 |     color: #ee4444;
42 |     font-size: 1.3em;
43 | }
44 | 
45 | .author {
46 |     color: #ee4444;
47 | }
48 | 
49 | .author a {
50 |     color: #ee4444;
51 | }
52 | 


--------------------------------------------------------------------------------
/doc/jekyll/documentation.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | section: "Documentation"
 4 | ---
 5 | 
 6 | # Documentation
 7 | 
 8 | __warnStart
 9 | 
10 | This Documentation is still **work in progress**. Several Sections are currently missing but will hopefully be added shortly.
11 | 
12 | __warnEnd
13 | 
14 | This is the semi-complete documentation of the `xerus` library. It does not provide you with precise function declarations or
15 | class hierarchies (check out the [doxygen documentation](/doxygen) for those) but instead focuses on small working code snippets
16 | to demonstrate `xerus`'s capabilities. 
17 | 
18 | The documentation is categorized into chapters that each focus on individual features of the library. In particular the chapters in the "Basic
19 | Usage" section only build upon the knowledge of the previous chapters so that they can easily be read in order. They are still
20 | useful as lookup resources later on though.
21 | 
22 | If you have not already done so, you will most likely want to start by downloading and [building xerus](/building_xerus). If
23 | you are uncertain or confused by our nomenclature at any point you can reference the [nomenclature](/nomenclature) chapter which
24 | should hopefully allow you to deduce the meaning of all tensor specific terms we use.
25 | 
26 | The "Basic Usage" section starts out with the creation and modification of (sparse or dense) tensors ([The Tensor Class](/tensor)),
27 | how to use them in indexed equations to denote contractions, summations etc. ([Indices and Equations](/indices)) and finally 
28 | how to denote generalizations of matrix decompositions ([Decompositions and Solve](/decompositions)) before explainig any more
29 | elaborate tensor format. The focus of `xerus` so far clearly lies on the Tensor Train decomposition ([TT-Tensors](/tttensors)) and
30 | algorithms for those to solve least squares problems ([Alternating Algorithms](/als), [Riemannian Algorithms](/riemannian)) or
31 | tensor recovery and completion problems ([Tensor Completion / Recovery](/completion)). It is possible to use `xerus`'s capabilities
32 | to construct and contract arbitrary tensor networks though ([General Tensor Networks](/tensornetworks)).
33 | 
34 | In the "Advanced Usage" section you find instructions on how to optimize your usage of the `xerus` library to gain those last
35 | 10-20% of speedup ([Optimization](/optimization)) and explanations of the debugging tools that `xerus` gives you ([Debugging](/debugging)).
36 | 


--------------------------------------------------------------------------------
/doc/jekyll/examples.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: post
 3 | section: "Examples"
 4 | ---
 5 | 
 6 | # Examples
 7 | 
 8 | Functional examples of library usage can help you to quickly gauge if it is the library you are looking for, can be very instructive
 9 | on how to practically use its capabilities and even serve as starting points for you own algorithms and programs. This is why
10 | we think it is very important to make practical examples available with a library.
11 | 
12 | Naturally this section could (always!) use more examples. So please do not hesitate to send us any code you have written using the
13 | `xerus` library, including comments and explanations, to [contact{at}libxerus.org](mailto:contact@libxerus.org).
14 | 


--------------------------------------------------------------------------------
/doc/jekyll/fonts/glyphicons-halflings-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/fonts/glyphicons-halflings-regular.eot


--------------------------------------------------------------------------------
/doc/jekyll/fonts/glyphicons-halflings-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/fonts/glyphicons-halflings-regular.ttf


--------------------------------------------------------------------------------
/doc/jekyll/fonts/glyphicons-halflings-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/fonts/glyphicons-halflings-regular.woff


--------------------------------------------------------------------------------
/doc/jekyll/fonts/glyphicons-halflings-regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/fonts/glyphicons-halflings-regular.woff2


--------------------------------------------------------------------------------
/doc/jekyll/images/cascade.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/images/cascade.png


--------------------------------------------------------------------------------
/doc/jekyll/images/xerus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/libxerus/xerus/7576ab70b5416d9f3f060eaa8d24eb9e97ab7f7c/doc/jekyll/images/xerus.png


--------------------------------------------------------------------------------
/doc/jekyll/js/npm.js:
--------------------------------------------------------------------------------
 1 | // This file is autogenerated via the `commonjs` Grunt task. You can require() this file in a CommonJS environment.
 2 | require('../../js/transition.js')
 3 | require('../../js/alert.js')
 4 | require('../../js/button.js')
 5 | require('../../js/carousel.js')
 6 | require('../../js/collapse.js')
 7 | require('../../js/dropdown.js')
 8 | require('../../js/modal.js')
 9 | require('../../js/tooltip.js')
10 | require('../../js/popover.js')
11 | require('../../js/scrollspy.js')
12 | require('../../js/tab.js')
13 | require('../../js/affix.js')


--------------------------------------------------------------------------------
/include/xerus.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Default include file for the xerus library.
23 |  */
24 | 
25 | // NOTE must not be "pragma once" as that keyword is not supported in precompiled headers
26 | #ifndef XERUS_H
27 | #define XERUS_H
28 | 
29 |     #define MISC_NAMESPACE xerus
30 |     
31 |     // The misc stuff needed by xerus
32 |     #include "xerus/misc.h"
33 |     
34 |     // File which sets the custom log levels
35 |     #include "xerus/tensorLogger.h"
36 | 
37 |     // All the xerus headers
38 | 	#include "xerus/blasLapackWrapper.h"
39 |     #include "xerus/index.h"
40 |     #include "xerus/indexedTensorReadOnly.h"
41 |     #include "xerus/indexedTensorWritable.h"
42 |     #include "xerus/indexedTensor.h"
43 |     #include "xerus/indexedTensorMoveable.h"
44 |     #include "xerus/indexedTensorList.h"
45 |     #include "xerus/tensor.h"
46 |     #include "xerus/cholmod_wrapper.h"
47 |     #include "xerus/sparseTimesFullContraction.h"
48 |     #include "xerus/sparseTimesFullContraction.h"
49 |     #include "xerus/indexedTensor_tensor_factorisations.h"
50 |     #include "xerus/tensorNetwork.h"
51 |     #include "xerus/contractionHeuristic.h"
52 |     #include "xerus/ttNetwork.h"
53 |     #include "xerus/ttStack.h"
54 | 	#include "xerus/performanceData.h"
55 | 	#include "xerus/measurments.h"
56 |     #include "xerus/algorithms/als.h"
57 |     #include "xerus/algorithms/steepestDescent.h"
58 |     #include "xerus/algorithms/cg.h"
59 |     #include "xerus/algorithms/decompositionAls.h"
60 |     #include "xerus/algorithms/adf.h"
61 |     #include "xerus/algorithms/uqAdf.h"
62 |     #include "xerus/algorithms/iht.h"
63 |     #include "xerus/algorithms/largestEntry.h"
64 |     
65 | 	#include "xerus/examples/specificLowRankTensors.h"
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/include/xerus/algorithms/decompositionAls.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the decomposition ALS algorithm. This is likely temporary.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "../ttNetwork.h"
28 | 
29 | namespace xerus {
30 | 	void decomposition_als(TTTensor& _x, const Tensor& _b, const double _eps = EPSILON, const size_t _maxIterations = 1000);
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/include/xerus/algorithms/iht.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the IHT algorithm and its variants.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "../ttNetwork.h"
28 | #include "../performanceData.h"
29 | #include "../measurments.h"
30 | 
31 | namespace xerus {
32 | 	double IHT(TTTensor& _x, const SinglePointMeasurementSet& _measurments, PerformanceData& _perfData = NoPerfData);
33 | }
34 | 
35 | 


--------------------------------------------------------------------------------
/include/xerus/algorithms/largestEntry.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the TT largest entry algorithm.
23 |  */
24 | 
25 | #pragma once
26 | #include "../ttNetwork.h"
27 | 
28 | namespace xerus {
29 | 	/** 
30 | 	 * @brief Finds the position of the approximately largest entry.
31 | 	 * @details Finds an entry that is at least of size @a _accuracy * X_max in absolute value,
32 | 	 * where X_max is the largest entry of the tensor. The smaller @a _accuracy, the faster the algorithm will work.
33 | 	 * @param _accuracy factor that determains the maximal deviation of the returned entry from the true largest entry.
34 | 	 * @param _lowerBound a lower bound for the largest entry, i.e. there must be an entry in the tensor which is at least of
35 | 	 * this size (in absolute value). The algorithm may fail completely if this is not fullfilled, but will work using its own 
36 | 	 * approximation if no value (i.e. 0.0) is given.
37 | 	 * @return the position of the entry found.
38 | 	 */
39 | 	template<bool isOperator>
40 | 	size_t find_largest_entry(const TTNetwork<isOperator> &_T, double _accuracy, value_t _lowerBound = 0.0);
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/include/xerus/algorithms/randomSVD.h:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | /**
 21 |  * @file
 22 |  * @brief Header file for the IHT algorithm and its variants.
 23 |  */
 24 | 
 25 | #pragma once
 26 | 
 27 | #include "../ttNetwork.h"
 28 | 
 29 | namespace xerus {
 30 |     
 31 | // TTTensor randomTTSVD(const Tensor& _x, const std::vector<size_t>& _ranks, const std::vector<size_t>& _oversampling) {
 32 | //     std::normal_distribution<double> dist(0, 1);
 33 | //     
 34 | //     const size_t d = _x.degree();
 35 | //     TTTensor u(d);
 36 | //     Tensor b = _x;
 37 | //     
 38 | //     for(size_t j = d; j >= 2; --j) {
 39 | //         const size_t s = _ranks[j-2] + _oversampling[j-2];
 40 | //         
 41 | //         const std::vector<size_t> mixDims(b.dimensions.cbegin(), b.dimensions.cbegin()+(j-1));
 42 | //         
 43 | //         std::vector<size_t> outDims({s});
 44 | //         outDims.insert(outDims.end(), b.dimensions.cbegin()+(j-1), b.dimensions.cend());
 45 | //         
 46 | //         Tensor a(outDims, Tensor::Representation::Sparse, Tensor::Initialisation::Zero);
 47 | //         
 48 | //         if(b.is_sparse()) {
 49 | //             const size_t staySize = misc::product(b.dimensions, j-1, b.dimensions.size());
 50 | //             
 51 | //             std::map<size_t, std::vector<value_t>> usedG;
 52 | //             
 53 | //             const auto& data = b.get_sparse_data();
 54 | //             for(const auto& entry : data) {
 55 | //                 const size_t pos = entry.first/staySize;
 56 | //                 const size_t outPos = entry.first%staySize;
 57 | //                 
 58 | //                 auto& gEntry = usedG[pos];
 59 | //                 if(gEntry.empty()) {
 60 | //                     gEntry.reserve(s);
 61 | //                     for(size_t k = 0; k < s; ++k) {
 62 | //                         gEntry.push_back(dist(xerus::misc::randomEngine));
 63 | //                     }
 64 | //                 }
 65 | //                 
 66 | //                 for(size_t k = 0; k < s; ++k) {
 67 | //                     a[outPos+k*staySize] += gEntry[k]*entry.second;
 68 | //                 }
 69 | //             }
 70 | //             
 71 | //         } else {
 72 | //             std::vector<size_t> gDims({s});
 73 | //             gDims.insert(gDims.end(), mixDims.cbegin(), mixDims.cend());
 74 | //             const Tensor g = Tensor::random(gDims, dist, xerus::misc::randomEngine);
 75 | //             contract(a, g, false, b, false, j-1);
 76 | //         }
 77 | //         
 78 | //         
 79 | //         Tensor R, Q;
 80 | //         calculate_rq(R, Q, a, 1);
 81 | //         
 82 | //         
 83 | //         if(j == d) {
 84 | //             contract(b, b, false, Q, true, 1);
 85 | //             Q.reinterpret_dimensions(Q.dimensions | std::vector<size_t>({1}));
 86 | //             u.set_component(j-1, Q);
 87 | //         } else {
 88 | //             contract(b, b, false, Q, true, 2);
 89 | //             u.set_component(j-1, Q); 
 90 | //         }
 91 | //     }
 92 | //     
 93 | //     b.reinterpret_dimensions(std::vector<size_t>({1}) | b.dimensions);
 94 | //     u.set_component(0, b);
 95 | //     
 96 | //     u.round(_ranks);
 97 | //     
 98 | //     return u;
 99 | }
100 | 
101 | 
102 | 


--------------------------------------------------------------------------------
/include/xerus/algorithms/uqAdf.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the ADF algorithm and its variants.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "../index.h"
28 | #include "../ttNetwork.h"
29 | #include "../performanceData.h"
30 | #include "../measurments.h"
31 | 
32 | namespace xerus {
33 |     
34 | 	
35 | 	class UQMeasurementSet {
36 | 	public:
37 | 		std::vector<std::vector<double>> randomVectors;
38 | 		std::vector<Tensor> solutions;
39 | 		
40 | 		std::vector<std::vector<double>> initialRandomVectors;
41 | 		std::vector<Tensor> initialSolutions;
42 | 		
43 | 		UQMeasurementSet() = default;
44 | 		UQMeasurementSet(const UQMeasurementSet&  _other) = default;
45 | 		UQMeasurementSet(      UQMeasurementSet&& _other) = default;
46 | 		
47 | 		void add(const std::vector<double>& _rndvec, const Tensor& _solution);
48 | 		
49 | 		void add_initial(const std::vector<double>& _rndvec, const Tensor& _solution);
50 | 	};
51 | 	
52 | 	
53 | 	
54 | 	void uq_adf(TTTensor& _x, const std::vector<std::vector<double>>& _randomVariables, const std::vector<Tensor>& _solutions);
55 | 	
56 | 	TTTensor uq_adf(const UQMeasurementSet& _measurments, const TTTensor& _guess);
57 | 	
58 | 	Tensor uq_avg(const TTTensor& _x, const size_t _N, const size_t _numSpecial);
59 | 	
60 | 	std::pair<std::vector<std::vector<double>>, std::vector<Tensor>> uq_mc(const TTTensor& _x, const size_t _N, const size_t _numSpecial);
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/include/xerus/basic.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for shorthand notations that are xerus specific but used throughout the library.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <stddef.h>
28 | #include "misc/allocator.h"
29 | #include "misc/standard.h"
30 | #include "misc/namedLogger.h"
31 | #include "tensorLogger.h"
32 | 
33 | /**
34 | * @brief The main namespace of xerus.
35 | * @details With very few exceptions all classes, functions and variables declared by the xerus are placed in this namespace.
36 | */
37 | namespace xerus {
38 |     /**
39 | 	 * @brief The type of values to be used by xerus.
40 | 	 * @details In future versions this should be allowed to be float, double, or complex.
41 | 	 * In the current version however this is fixed to double.
42 | 	 */
43 | 	typedef double value_t;
44 | 	
45 | 	/**
46 | 	 * @brief The default epsilon value in xerus.
47 | 	 * @details This value is used as a default value by all xerus routines that work up to a certain accuracy,
48 | 	 * e.g. the singluar value decompostion or the ALS algorithm.
49 | 	 */
50 | 	constexpr const value_t EPSILON = 8*std::numeric_limits<value_t>::epsilon();
51 |     
52 | 	/**
53 | 	* @brief Namespace for function and classes designated only for internal use.
54 | 	* @details End users should never be required to know or explicitly use classes or functions from this
55 | 	* namespace. If you want to do so nevertheless be aware of the minimalistic documentation and in some cases 
56 | 	* quite unexpected behavior.
57 | 	*/
58 | 	namespace internal {
59 | 		/// @brief Internal deleter function, needed because std::shared_ptr misses an array overload.
60 | 		void array_deleter_vt(value_t* const _toDelete);
61 | 		
62 | 		/// @brief Internal deleter function, needed because std::shared_ptr misses an array overload.
63 | 		void array_deleter_st(size_t* const _toDelete);
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/include/xerus/contractionHeuristic.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the class managing the contraction heuristics.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <vector>
28 | 
29 | #include "basic.h"
30 | 
31 | namespace xerus {
32 | 	class TensorNetwork;
33 | 	
34 | 	namespace internal {
35 | 		typedef void (*ContractionHeuristic)(double &, std::vector<std::pair<size_t,size_t>> &, TensorNetwork);
36 | 		
37 | 		template<double (*scoreFct)(double, double, double, double, double)>
38 | 		void greedy_heuristic(double &_bestCost, std::vector<std::pair<size_t,size_t>> &_contractions, TensorNetwork _network);
39 | 		
40 | 		double contraction_cost(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
41 | 		
42 | 		double score_size(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
43 | 		double score_mn(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
44 | 		double score_speed(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
45 | 		double score_r(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
46 | 		double score_big_tensor(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
47 | 		double score_littlestep(double _m, double _n, double _r, double _sparsity1, double _sparsity2);
48 | 		
49 | 		
50 | 		void greedy_best_of_three_heuristic(double &_bestCost, std::vector<std::pair<size_t,size_t>> &_contractions, TensorNetwork _network);
51 | 		void exchange_heuristic(double &_bestCost, std::vector<std::pair<size_t,size_t>> &_contractions, TensorNetwork _network);
52 | 		
53 | 		extern const std::vector<ContractionHeuristic> contractionHeuristics;
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/include/xerus/examples/specificLowRankTensors.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for some examples of low-rank TT tensors.
23 |  */
24 | 
25 | #pragma once
26 | #include "../ttNetwork.h"
27 | 
28 | namespace xerus { namespace examples {
29 | 	
30 | 	/**
31 | 	 * @brief Constructs a rank _n+1 TTTensor of degree @a _degree and external dimensions @a _n that has entries >0, maximal where all indices coincide.
32 | 	 * @details Constructed as a sum of nearest-neighbor terms that each have entries as 1/(std::abs(i-j)+alpha)
33 | 	 */
34 | 	TTTensor peaking_diagonals(size_t _degree, size_t _n, value_t _alpha = 1.0);
35 | 	
36 | }}
37 | 
38 | 


--------------------------------------------------------------------------------
/include/xerus/examples/tensorCompletion.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for some example measure sets for tensor completion.
23 |  */
24 | 
25 | #pragma once
26 | #include "../ttNetwork.h"
27 | #include "../measurments.h"
28 | 
29 | namespace xerus { namespace examples { namespace completion {
30 | 	
31 | 	/**
32 | 	 * @brief fills in the values of the @a _measurements as @$ 1/\sqrt{\sum i_\mu^2} @$
33 | 	 * @details the corresponding tensor is only approximately low-rank, cf. Hackbusch, 2012 "Tensor spaces and numerical tensor calculus" and http://www.mis.mpg.de/scicomp/EXP_SUM
34 | 	 * @note that index (0,0,0,0...) is singular for @a _additiveConst = 0
35 | 	 */
36 | 	value_t inverse_index_norm(const std::vector<size_t>& _position, const value_t _additiveConst = 1.0);
37 | 	
38 | 	
39 | 	
40 | 	/**
41 | 	 * @brief fills in the values of the @a _measurements as @$ (\alpha + \sum i_\mu/(i_{\mu+1} + \alpha - 1))^{-1} @$
42 | 	 * @details the corresponding tensor is only approximately low-rank, cf. Grasedyck, Kluge, Kraemer 2015
43 | 	 */
44 | 	value_t inverse_index_ratio(const std::vector<size_t>& _position, const value_t _additiveConst = 1.0);
45 | }}}
46 | 
47 | 


--------------------------------------------------------------------------------
/include/xerus/indexedTensor.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the IndexedTensor class.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "indexedTensorWritable.h"
28 | 
29 | namespace xerus {
30 | 	namespace internal {
31 | 		template<class tensor_type>
32 | 		/**
33 | 		* @brief Internal representation of an readable and writeable indexed Tensor or TensorNetwork.
34 | 		* @details This class appears inplicitly by indexing any Tensor or TensorNetwork. It is not recommended to use
35 | 		* it explicitly or to store variables of this type (unless you really know what you are doing).
36 | 		*/
37 | 		class IndexedTensor final : public IndexedTensorWritable<tensor_type> {
38 | 		public:     
39 | 			///@brief There is no usefull copy constructor, because the handling of the tensorObject is unclear.
40 | 			IndexedTensor(const IndexedTensor &_other ) = delete;
41 | 			
42 | 			///@brief Move constructor
43 | 			IndexedTensor(IndexedTensor &&_other );
44 | 			
45 | 			///@brief Constructs an IndexedTensor with the given tensor and indices and if ordered to do so takes owership of the tensorObject
46 | 			IndexedTensor(tensor_type* const _tensorObject, const std::vector<Index>&  _indices, const bool _takeOwnership);
47 | 			
48 | 			///@brief Constructs an IndexedTensor with the given tensor and indices and if ordered to do so takes owership of the tensorObject
49 | 			IndexedTensor(tensor_type* const _tensorObject,       std::vector<Index>&& _indices, const bool _takeOwnership);
50 | 				
51 | 			/**
52 | 			* @brief Assignment operators -- Used for tensor assignment WITH indices.
53 | 			* @details Note that this is NOT a classical assignment operator. In particular this and _rhs are NOT equivalent after
54 | 			* the assignment.
55 | 			*/
56 | 			void operator=(IndexedTensorReadOnly<Tensor>&& _rhs);
57 | 			
58 | 			/**
59 | 			* @brief Assignment operators -- Used for tensor assignment WITH indices.
60 | 			* @details Note that this is NOT a classical assignment operator. In particular this and _rhs are NOT equivalent after
61 | 			* the assignment.
62 | 			*/
63 | 			void operator=(IndexedTensorReadOnly<TensorNetwork>&& _rhs);
64 | 			
65 | 			/**
66 | 			* @brief Tensor add_assignment with indices.
67 | 			*/
68 | 			void operator+=(IndexedTensorReadOnly<tensor_type>&& _rhs);
69 | 			
70 | 			/**
71 | 			* @brief Tensor subtract_assignment with indices.
72 | 			*/
73 | 			void operator-=(IndexedTensorReadOnly<tensor_type>&& _rhs);
74 | 			
75 | 			///@brief The following would be deleted due to move constructor and is therefore implemented here, calls the IndexedTensorReadOnly version. 
76 | 			void operator=(IndexedTensor<tensor_type>&& _rhs);
77 | 		};
78 | 	}
79 | }


--------------------------------------------------------------------------------
/include/xerus/indexedTensorList.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file defining lists of indexed tensors.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <vector>
28 | 
29 | namespace xerus {
30 | 	// Necessary forward declaritons
31 | 	class Tensor;
32 | 	class TensorFactorisation;
33 | 	
34 | 	namespace internal {
35 | 		template<class tensor_type> class IndexedTensor;
36 | 		/**
37 | 		* @brief Internal representation of a tuple of indexed Tensor s.
38 | 		* @details This class appears inplicitly by using expressiong like (Q(i,r), R(r,j)) and is particulary used for a convinient syntax for Tensor factorisations.
39 | 		*/
40 | 		class IndexedTensorList {
41 | 		public:
42 | 			///@brief Collection of pointers to the Tensor objects referenced by the tuple.
43 | 			std::vector<IndexedTensor<Tensor>*> tensors;
44 | 			
45 | 			///@brief No default construction is intended.
46 | 			IndexedTensorList() = delete;
47 | 			
48 | 			///@brief No copy construction is intended.
49 | 			IndexedTensorList(const IndexedTensorList& _old) = delete;
50 | 			
51 | 			///@brief Move constructor.
52 | 			IndexedTensorList(IndexedTensorList&& _old) noexcept;
53 | 			
54 | 			/**
55 | 			* @brief constructor initializing an IndexedTensorList with two initial Tensor refrences.
56 | 			*/
57 | 			IndexedTensorList(IndexedTensor<Tensor>&& _first, IndexedTensor<Tensor>&& _second);
58 | 			
59 | 			/**
60 | 			* @brief Generic assignment operator that takes any TensorFactorisation object which is in then invoked to perform the assignment.
61 | 			*/
62 | 			void operator=(TensorFactorisation&& _factorisation) const;
63 | 		};
64 | 
65 | 		/**
66 | 		* @brief Using the "," operator tuples of writeable indexed tensor can be created.
67 | 		* @param _first the first element of the tuple.
68 | 		* @param _second the second element of the tuple.
69 | 		* @returns an IndexedTensorList representing the desired 2-tuple.
70 | 		*/
71 | 		IndexedTensorList operator,(IndexedTensor<Tensor>&& _first, IndexedTensor<Tensor>&& _second);
72 | 
73 | 		/**
74 | 		* @brief Using the "," operator tuples of writeable indexed tensor can be created.
75 | 		* @param _first an existing tuple of writeable indexed tensor.
76 | 		* @param _second a further writeable indexed tensor that shall be appended to the existing tuple.
77 | 		* @returns an IndexedTensorList representing the desired (n+1)-tuple.
78 | 		*/
79 | 		IndexedTensorList operator,(IndexedTensorList &&_first, IndexedTensor<Tensor>&& _second);
80 | 	}
81 | }
82 | 


--------------------------------------------------------------------------------
/include/xerus/misc.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Default include file for the misc (ie. non-tensor) functionality.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "misc/check.h"
28 | #include "misc/standard.h"
29 | #include "misc/namedLogger.h"
30 |  
31 | #include "misc/basicArraySupport.h"
32 | #include "misc/containerSupport.h"
33 | #include "misc/stringUtilities.h"
34 | #include "misc/sfinae.h"
35 | #include "misc/callStack.h"
36 | #include "misc/simpleNumerics.h"
37 | #include "misc/timeMeasure.h"
38 | #include "misc/performanceAnalysis.h"
39 | #include "misc/exceptions.h"
40 | #include "misc/allocator.h"
41 | #include "misc/histogram.h"
42 | #include "misc/sort.h"
43 | #include "misc/math.h"
44 | #include "misc/missingFunctions.h"
45 | #include "misc/fileIO.h"
46 | #include "misc/stringFromTo.h"
47 | #include "misc/random.h"
48 | 


--------------------------------------------------------------------------------
/include/xerus/misc/allocator.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the data structures used by the custom new and delete operators
23 |  */
24 | 
25 | 
26 | #pragma once
27 | 
28 | #ifdef XERUS_REPLACE_ALLOCATOR
29 | 
30 | 	#include <cstdio>
31 | 	#include <cstdlib>
32 | 	#include <vector>
33 | 	#include <array>
34 | 	#include <set>
35 | 	#include <ext/malloc_allocator.h>
36 | 
37 | 	namespace xerus { namespace misc {
38 | 
39 | 	extern void* (*r_malloc)(size_t);
40 | 	extern void (*r_free)(void*);
41 | 		
42 | 	using Mallocator = __gnu_cxx::malloc_allocator<void*>;
43 | 
44 | 	struct AllocatorStorage {
45 | 		static constexpr const size_t POOL_SIZE = 4*1024*1024;
46 | 		static constexpr const size_t BUCKET_SIZE = 64;
47 | 		static constexpr const size_t ALIGNMENT = 64;
48 | 		static constexpr const size_t NUM_BUCKETS = 64;
49 | 		static constexpr const size_t SMALLEST_NOT_CACHED_SIZE = BUCKET_SIZE * NUM_BUCKETS - 1;
50 | 		
51 | 		static_assert(BUCKET_SIZE > 1, "Buckets need to be at least 2 bytes large.");
52 | 		static_assert(BUCKET_SIZE % ALIGNMENT == 0, "Bucket size needs to be aligned");
53 | 		static_assert(ALIGNMENT <= 256, "Only alignment up to 256 bytes is supported as only a single byte is used to indicate the offset.");
54 | 		static_assert(NUM_BUCKETS < 255, "atm only a single byte is used to store bucket size");
55 | 		
56 | 		std::array<std::vector<uint8_t*, Mallocator>, NUM_BUCKETS> buckets;
57 | 		std::vector<std::pair<uint8_t*, uint8_t*>, Mallocator> pools;
58 | 		
59 | 		AllocatorStorage();
60 | 		~AllocatorStorage();
61 | 		
62 | 		void create_new_pool();
63 | 
64 | 		unsigned long allocCount[NUM_BUCKETS];
65 | 		long maxAlloc[NUM_BUCKETS];
66 | 		long currAlloc[NUM_BUCKETS];
67 | 	};
68 | 
69 | 	extern thread_local AllocatorStorage astore;
70 | 	}}
71 | 
72 | #endif
73 | 
74 | 


--------------------------------------------------------------------------------
/include/xerus/misc/callStack.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Header file for the call-stack functionality.
23 | */
24 | 
25 | #pragma once 
26 | 
27 | #include <string>
28 | #include <utility>
29 | 
30 | namespace xerus {
31 | 	namespace misc {
32 | 		/**
33 | 		* @brief Returns a string representation of the current call-stack (excluding the function itself).
34 | 		* @details Per default this uses the binutils library to get the following information:
35 | 		* [address .section] filename:line (function)
36 | 		* if all of these are available. 
37 | 		*/
38 | 		std::string get_call_stack();
39 | 		
40 | 		/**
41 | 		* @brief Returns the address range of the elf-section names @a _name as part of the executable / so file that contained @a _addr.
42 | 		*/
43 | 		std::pair<uintptr_t, uintptr_t> get_range_of_section(void* _addr, std::string _name);
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/include/xerus/misc/containerOutput.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Header file for the standard container to standard ostream operators.
23 | */
24 | 
25 | #pragma once
26 | #include <tuple>
27 | #include <set>
28 | #include <vector>
29 | #include <map>
30 | #include <iostream>
31 | 
32 | namespace xerus { namespace misc {
33 | 		// Internal Helper function to print tuples.
34 | 	namespace internal {
35 | 		template<size_t n = 0, typename... Tp, typename std::enable_if<n+1 == sizeof...(Tp), int>::type = 0>
36 | 		inline void print(std::ostream& _out, const std::tuple<Tp...>& t) {
37 | 			_out << std::get<n>(t);
38 | 		}
39 | 
40 | 		template<size_t n = 0, typename... Tp, typename std::enable_if<n+1 < sizeof...(Tp), int>::type = 0>
41 | 		inline void print(std::ostream& _out, const std::tuple<Tp...>& t) {
42 | 			_out << std::get<n>(t) << ", ";
43 | 			print<n + 1, Tp...>(_out, t);
44 | 		}
45 | 	}
46 | 	
47 | 
48 | 	///@brief Allow to pipe tuples to ostreams.
49 | 	template<class... Tp>
50 | 	std::ostream& operator<<(std::ostream& _out, const std::tuple<Tp...>& _tuple) {
51 | 		_out << "<";
52 | 		xerus::misc::internal::print<0, Tp...>(_out, _tuple);
53 | 		_out << ">";
54 | 		return _out;
55 | 	}
56 | 	
57 | 	
58 | 	///@brief Allow to pipe std::pairs to ostreams.
59 | 	template<class first_t, class second_t>
60 | 	std::ostream& operator<<(std::ostream& _out, const std::pair<first_t, second_t>& _pair) {
61 | 		_out << "[ " << _pair.first << " | " << _pair.second << " ]";
62 | 		return _out;
63 | 	}
64 | 	
65 | 	
66 | 	///@brief Allow to pipe normal containers to ostreams.
67 | 	template<class item_t, class... rest_t>
68 | 	std::ostream& operator<<(std::ostream& _out, const std::vector<item_t, rest_t...>& _container) {
69 | 		if(_container.size() == 0) { _out << "{ }"; return _out; }
70 | 		_out << "{ ";
71 | 		for(const item_t& item : _container) { _out << item << ", "; }
72 | 		_out << "\b\b }";
73 | 		return _out;
74 | 	}
75 | 	
76 | 	
77 | 	///@brief Allow to pipe std::sets to ostreams.
78 | 	template<class item_t, class... rest_t>
79 | 	std::ostream& operator<<(std::ostream& _out, const std::set<item_t, rest_t...>& _container) {
80 | 		if(_container.size() == 0) { _out << "{ }"; return _out; }
81 | 		_out << "{ ";
82 | 		for(const item_t& item : _container) { _out << item << ", "; }
83 | 		_out << "\b\b }";
84 | 		return _out;
85 | 	}
86 | 	
87 | 	
88 | 	///@brief Allow to pipe std::maps to ostreams.
89 | 	template<class T, class U>
90 | 	std::ostream& operator<<(std::ostream& _out, const std::map<T,U>& _set) {
91 | 		if(_set.size() == 0) { _out << "{ }"; return _out; }
92 | 		_out << "{ ";
93 | 		for(const auto& item : _set) {  _out << "(" << item.first << ", " << item.second << "), "; }
94 | 		_out << "\b\b }";
95 | 		return _out;
96 | 	}
97 | 	
98 | }} // namespaces xerus::misc
99 | 


--------------------------------------------------------------------------------
/include/xerus/misc/exceptions.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for xerus::misc::generic_error exception class.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <exception>
28 | #include <sstream>
29 | #include "stringFromTo.h"
30 | 
31 | namespace xerus {
32 |     namespace misc {
33 | 		/**
34 | 		 * @brief The xerus exception class.
35 | 		 * @details All exceptions thrown by xerus are of this type (or subclasses thereof).
36 | 		 */
37 |         class generic_error : public std::exception {
38 |         public:
39 | 			///@brief String containing all relevant information concerning this error.
40 |             std::string error_info;
41 |             
42 | 			/// @brief: Normal constructor without preset error_info.
43 |             generic_error();
44 |             
45 | 			/// @brief Standard copy constructor.
46 |             generic_error(const generic_error &_other) noexcept;
47 |             
48 |             const char* what() const noexcept override;
49 |         };
50 | 		
51 | 		/// @brief The pipe operator allows to add everything that can be converted to string to the error_info and derived exceptions. 
52 | 		template<typename error_t, class T>
53 | 		typename std::enable_if<std::is_base_of<generic_error, error_t>::value, error_t&>::type
54 | 		operator<< (error_t &o, const T &_info) noexcept {
55 | 			o.error_info += to_string(_info);
56 | 			return o;
57 | 		}
58 | 		
59 | 		/// @brief The pipe operator allows to add everything that can be converted to string to the error_info and derived exceptions. 
60 | 		template<typename error_t, class T>
61 | 		typename std::enable_if<std::is_base_of<generic_error, error_t>::value, error_t&>::type
62 | 		operator<< (error_t &&o, const T &_info) noexcept {
63 | 			o.error_info += to_string(_info);
64 | 			return o;
65 | 		}
66 |     }
67 | }
68 | 
69 | /**
70 |  * @def XERUS_THROW(...)
71 |  * @brief Helper macro to throw a generic_error (or derived exception) with some additional information included (function name, file name and line number).
72 |  */
73 | #define XERUS_THROW(...) throw (__VA_ARGS__ << "\nexception thrown in function: " << (__func__) << " (" << (__FILE__) <<" : " << (__LINE__) << ")\n")
74 | 


--------------------------------------------------------------------------------
/include/xerus/misc/histogram.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the histogram classes.
23 |  */
24 | 
25 | #pragma once 
26 | 
27 | #include <string>
28 | #include <fstream>
29 | #include <map>
30 | 
31 | namespace xerus { 
32 | 	namespace misc {
33 | 
34 | 		/**
35 | 		* @brief A logarithmic histogram, i.e. the size of all buckets is given by a constant factor [x - x*base)
36 | 		*/
37 | 		class LogHistogram {
38 | 		public:
39 | 			double base;
40 | 			std::map<int, size_t> buckets;
41 | 			size_t totalCount;
42 | 			
43 | 			explicit LogHistogram(const double _base);
44 | 			
45 | 			LogHistogram &operator+=(const LogHistogram &_other);
46 | 			void add(double _value, size_t _count = 1);
47 | 			
48 | 			static LogHistogram read_from_file(const std::string &_fileName);
49 | 			void dump_to_file(const std::string &_fileName) const;
50 | 		};
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/include/xerus/misc/internal.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for comfort functions and macros that should not be exported in the library.
23 |  * @note this may only be used in cpp files and must NOT be included in any library header!
24 |  */
25 | 
26 | 
27 | #pragma once
28 | #include "containerOutput.h"
29 | #include <type_traits>
30 | #include <memory>
31 | 
32 | // macro shorthands
33 | #define REQUIRE 		XERUS_REQUIRE
34 | #define CHECK			XERUS_CHECK
35 | #define IF_CHECK		XERUS_IF_CHECK
36 | #define IF_NO_CHECK		XERUS_IF_NO_CHECK
37 | #define INTERNAL_CHECK	XERUS_INTERNAL_CHECK
38 | #define LOG				XERUS_LOG
39 | #define LOG_SHORT		XERUS_LOG_SHORT
40 | #define LOG_ONCE		XERUS_LOG_ONCE
41 | #define IS_LOGGING		XERUS_IS_LOGGING
42 | #define SET_LOGGING		XERUS_SET_LOGGING
43 | 
44 | 
45 | 
46 | namespace std {
47 | #if !defined(__cplusplus) || __cplusplus < 201402L
48 | 	template<typename T, typename... Args>
49 | 	std::unique_ptr<T> make_unique(Args&&... args) {
50 | 	    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
51 | 	}
52 | #endif
53 | 	
54 | 	
55 | 	using ::xerus::misc::operator<<; // for std::ostream << std::vector etc.
56 | 	
57 | 	//TODO No good solution, as this requires the use of std::advance, which may be less efficient than the +operator for random access iterators. (Need concepts)
58 | 	///@brief Add a + operator for iterators and size_t to avoid signed/unsigned errors.
59 | 	template<class IteratorType, 
60 | 		typename std::enable_if<
61 | 			std::is_same<typename std::iterator_traits<IteratorType>::difference_type, long>::value
62 | 			&& std::is_class<IteratorType>::value
63 | 		, bool>::type = true>
64 | 	IteratorType operator+(const IteratorType& _iterator, const size_t _add) {
65 | 		IteratorType itr = _iterator;
66 | 		std::advance(itr, _add);
67 | 		return itr;
68 | 	}
69 | 	
70 | 	
71 | 	///@brief: Concatenates two given cointainers.
72 | 	template<template<class, class...> class container_t, class item_t, class... rest_t>
73 | 	container_t<item_t, rest_t...> operator |(const container_t<item_t, rest_t...> & _left, const container_t<item_t, rest_t...> & _right) {
74 | 		container_t<item_t, rest_t...> both(_left);
75 | 		both.insert(both.end(), _right.begin(), _right.end());
76 | 		return both;
77 | 	}
78 | }
79 | 


--------------------------------------------------------------------------------
/include/xerus/misc/math.h:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | /**
 21 | * @file
 22 | * @brief Header file for some additional math functions.
 23 | */
 24 | 
 25 | #pragma once
 26 | 
 27 | #include <limits>
 28 | #include <cmath>
 29 | #include "standard.h"
 30 | #include "sfinae.h"
 31 | 
 32 | namespace xerus {
 33 | 	namespace misc {
 34 | 		///@brief: Calculates the signum (-1, 0, 1) of a given value.
 35 | 		template<class T> 
 36 | 		constexpr int sgn(const T _value) noexcept {
 37 | 			return (T(0) < _value) - (_value < T(0));
 38 | 		}
 39 | 		
 40 | 		
 41 | 		///@brief: Calculates _a*_a.
 42 | 		template<class T>
 43 | 		constexpr T sqr(const T &_a) noexcept {
 44 | 			return _a*_a;
 45 | 		}
 46 | 		
 47 | 		
 48 | 		///@brief: Calculates _base^_exp by binary exponentiation
 49 | 		template<class T, class I, typename std::enable_if<std::is_integral<I>::value && std::is_unsigned<I>::value, bool>::type = true> 
 50 | 		constexpr T pow(const T &_base, const I _exp) noexcept {
 51 | 			return _exp==0 ? T(1) : (_exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)));
 52 | 		}
 53 | 		
 54 | 		
 55 | 		///@brief: Calculates _base^_exp by binary exponentiation
 56 | 		template<class T, class I, typename std::enable_if<std::is_integral<I>::value && !std::is_unsigned<I>::value, bool>::type = true> 
 57 | 		constexpr T pow(const T &_base, const I _exp) noexcept {
 58 | 			return _exp==0 ? 
 59 | 						T(1) :
 60 | 						(
 61 | 							_exp<0 ? 
 62 | 								T( 1/pow(_base, -_exp)) 
 63 | 							: 
 64 | 								( _exp%2==0 ? pow(T(_base*_base), _exp/2) : T(_base*pow(_base, _exp-1)) )
 65 | 						);
 66 | 		}
 67 | 		
 68 | 		
 69 | 		///@brief: Checks whether the relative difference between @a _a and @a _b (i.e. |a-b|/(|a|/2+|b|/2)) is smaller than @a _eps.
 70 | 		template<class T, typename std::enable_if<std::is_floating_point<T>::value, bool>::type = true>
 71 | 		bool approx_equal(T _a, T _b, T _eps = 4*std::numeric_limits<T>::epsilon()) noexcept {
 72 | 			return std::abs(_a-_b) <= _eps*0.5*(std::abs(_a)+std::abs(_b));
 73 | 		}
 74 | 		
 75 | 		
 76 | 		///@brief: Checks whether @a _a and @a _b are equal (for non floating point types).
 77 | 		template<class T, typename std::enable_if<!std::is_floating_point<T>::value, bool>::type = true>
 78 | 		bool approx_equal(T _a, T _b) {
 79 | 			return _a == _b;
 80 | 		}
 81 | 		
 82 | 		
 83 | 		///@brief: Checks for hard equality ( == operator) without compiler warnings.
 84 | 		template<class T>
 85 | 		constexpr bool hard_equal(const T _a, const T _b) noexcept {
 86 | 			#pragma GCC diagnostic push
 87 | 				#pragma GCC diagnostic ignored "-Wfloat-equal"
 88 | 				return _a == _b;
 89 | 			#pragma GCC diagnostic pop
 90 | 		}
 91 | 		
 92 | 		
 93 | 		///@brief: Checks for hard inequality ( != operator) without compiler warnings.
 94 | 		template<class T>
 95 | 		constexpr bool hard_not_equal(const T _a, const T _b) noexcept {
 96 | 			#pragma GCC diagnostic push
 97 | 				#pragma GCC diagnostic ignored "-Wfloat-equal"
 98 | 				return _a != _b;
 99 | 			#pragma GCC diagnostic pop
100 | 		}
101 | 	}
102 | }
103 | 


--------------------------------------------------------------------------------
/include/xerus/misc/missingFunctions.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Header file for some helper functions.
23 | */
24 | 
25 | #pragma once
26 | 
27 | #include <string>
28 | 
29 | namespace xerus {
30 | 	namespace misc {
31 | 		/**
32 | 		* @brief Execute a given command.
33 | 		* @param _cmd the command to execute
34 | 		* @return the cout return of the command.
35 | 		*/
36 | 		std::string exec(const std::string &_cmd);
37 | 		
38 | 		
39 | 		/**
40 | 		* @brief Execute a given command and pipe _stdin to its std input,
41 | 		* @param _cmd the command to execute
42 | 		* @param _stdin the input for the program
43 | 		*/
44 | 		void exec(const std::string & _cmd, const std::string &_stdin);
45 | 	}
46 | }
47 | 


--------------------------------------------------------------------------------
/include/xerus/misc/performanceAnalysis.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the performance analysis global objects and analysis function.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "standard.h"
28 | #include <string>
29 | 
30 | #ifdef XERUS_PERFORMANCE_ANALYSIS
31 | 	#include <map>
32 | 	#include <utility>
33 | 	#include "timeMeasure.h"
34 | 	#define XERUS_PA_START const size_t pa_startTime = misc::uTime()
35 | 	#define XERUS_PA_END(group, name, parameter) { std::pair<size_t, size_t>& pa_call = xerus::misc::performanceAnalysis::calls[group][name][parameter]; pa_call.first++; pa_call.second += misc::uTime() - pa_startTime; }
36 | #else 
37 | 	#define XERUS_PA_START 
38 | 	#define XERUS_PA_END(group, name, parameter)
39 | #endif
40 | 
41 | namespace xerus {
42 | 	namespace misc {
43 | 		/// @brief This namespace contains all functions only used for the performance analysis, as well as the respective global variables.
44 | 		namespace performanceAnalysis {
45 | 			#ifdef XERUS_PERFORMANCE_ANALYSIS
46 | 				extern const size_t startupTime;
47 | 				extern std::map<std::string, std::map<std::string, std::map<std::string, std::pair<size_t, size_t>>>> calls;
48 | 			#endif
49 | 			
50 | 			/// @brief Returns a detailed performance analysis if XERUS_PERFORMANCE_ANALYSIS is set, an emtpy string otherwise.
51 | 			std::string get_analysis();
52 | 		}
53 | 	}
54 | }
55 | 
56 | 	
57 | 


--------------------------------------------------------------------------------
/include/xerus/misc/random.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Header file for some additional math functions.
23 | */
24 | 
25 | #pragma once
26 | 
27 | #include <random>
28 | 
29 | #include "standard.h"
30 | 
31 | namespace xerus {
32 | 	namespace misc {
33 | 		extern thread_local std::mt19937_64 randomEngine;
34 | 		extern thread_local std::normal_distribution<double> defaultNormalDistribution;
35 | 	}
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/include/xerus/misc/sfinae.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for macros that encapsulate SFINAE functionality.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <type_traits>
28 | 
29 | /**
30 |  * @def XERUS_ADD_MOVE(newTypeName, oldTypeName)
31 |  * @brief Adds a template arguments whithin an existing template argument list, which can be of only one specified class, but allows & and && types.
32 |  */
33 | #define XERUS_ADD_MOVE(newTypeName, ...) class newTypeName, typename std::enable_if<std::is_base_of<__VA_ARGS__, typename std::decay<newTypeName>::type>::value, int>::type = 0
34 | 
35 | 
36 | /**
37 |  * @def XERUS_GENERATE_HAS_MEMBER(member)
38 |  * @brief Macro to create a template class that checks for the existence of member functions. To be used in other template definitions in a SFINAE fashion.
39 |  */
40 | #if __GNUC__ > 4 || defined(__clang__)
41 | 	// template void
42 | 	template<class...> using void_t = void;
43 | 
44 | 
45 | 	#define XERUS_GENERATE_HAS_FUNCTION(function)\
46 | 	namespace sfinae {\
47 | 		template<class, class, class = void>\
48 | 		struct has_##function : std::false_type {};\
49 | 		\
50 | 		template<class clas, class arg>\
51 | 		struct has_##function<clas, arg, void_t<decltype(std::declval<clas>().function(std::declval<arg>()))>> : std::true_type {};\
52 | 	}\
53 | 	\
54 | 	
55 | 	
56 | 	// TODO Gives a false positive if a function can be called by implicit casting!
57 | 	#define XERUS_GENERATE_EXISTS_FUNCTION(function)\
58 | 	namespace sfinae {\
59 |         template<class, class = void>\
60 |         struct exists_##function : std::false_type {};\
61 |         \
62 |         template<class arg>\
63 |         struct exists_##function<arg, void_t<decltype(function(std::declval<arg>()))>> : std::true_type {};\
64 | 	}\
65 | 	\
66 | 
67 | #else
68 | 	#define XERUS_GENERATE_HAS_MEMBER(member)											   \
69 | 	\
70 | 	template < class T >															  \
71 | 	class HasMember_##member														  \
72 | 	{																				 \
73 | 	public:																		  \
74 | 		typedef char (& yes)[1];							\
75 | 		typedef char (& no)[2];							\
76 | 		\
77 | 		template <typename C> static yes check(decltype(&C::member));		\
78 | 		template <typename> static no check(...);					\
79 | 		\
80 | 		static constexpr bool RESULT = sizeof(check<T>(0)) == sizeof(yes);		\
81 | 		};																				\
82 | 		\
83 | 		template < class T >															  \
84 | 		struct has_member_##member														\
85 | 		: public std::integral_constant<bool, HasMember_##member<T>::RESULT>			  \
86 | 		{ };																			  \
87 | 
88 | #endif
89 | 


--------------------------------------------------------------------------------
/include/xerus/misc/sort.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Header file for some extended sorting functions.
23 | */
24 | 
25 | #include <vector>
26 | #include <algorithm>
27 | 
28 | #include "check.h"
29 | 
30 | namespace xerus {
31 | 	namespace misc {
32 | 		template<class T, class Comparator>
33 | 		std::vector<size_t> create_sort_permutation(const std::vector<T>& _vec, Comparator _comp) {
34 | 			std::vector<size_t> permutation(_vec.size());
35 | 			std::iota(permutation.begin(), permutation.end(), 0);
36 | 			std::sort(permutation.begin(), permutation.end(), [&](const size_t _i, const size_t _j){ return _comp(_vec[_i], _vec[_j]); });
37 | 			return permutation;
38 | 		}
39 | 		
40 | 		template<class T>
41 | 		void apply_permutation( std::vector<T>& _vec, const std::vector<size_t>& _permutation) {
42 | 			XERUS_REQUIRE(_vec.size() == _permutation.size(), "Vector and permutation size must coincide.");
43 | 			std::vector<T> sorted_vec;
44 | 			sorted_vec.reserve(_permutation.size());
45 | 			for(size_t i = 0; i < _permutation.size(); ++i) {
46 | 				sorted_vec.emplace_back(std::move(_vec[_permutation[i]]));
47 | 			}
48 | 			_vec = std::move(sorted_vec);
49 | 		}
50 | 		
51 | 		template <class KeyType, class DataType, class Comparator>
52 | 		void simultaneous_sort( std::vector<KeyType>& _keyVector, std::vector<DataType>& _dataVector, Comparator _comp) {
53 | 			XERUS_REQUIRE(_keyVector.size() == _dataVector.size(), "Vector sizes must coincide.");
54 | 			const std::vector<size_t> permutation = create_sort_permutation(_keyVector, _comp);
55 | 			apply_permutation(_keyVector, permutation);
56 | 			apply_permutation(_dataVector, permutation);
57 | 		}
58 | 	}
59 | }
60 | 


--------------------------------------------------------------------------------
/include/xerus/misc/standard.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for global shorthand notations of elementary integer types and attribute lists.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <stddef.h>
28 | #include <cstdint>
29 | #include <cstddef>
30 | 
31 | namespace xerus {
32 | 	/**
33 | 	 * @brief Collection of classes and functions that provide elementary functionality that is not special to xerus as a tensor library.
34 | 	 */
35 | 	namespace misc {
36 | 		/// @brief Namespace for function and classes designated only for internal use.
37 | 		namespace internal {}
38 | 	}
39 | 	
40 | 	/**
41 | 	 * The version of the compiled xerus library
42 | 	 */
43 | 	extern const int VERSION_MAJOR;
44 | 	extern const int VERSION_MINOR;
45 | 	extern const int VERSION_REVISION;
46 | 	extern const int VERSION_COMMIT;
47 | 
48 |     // Shorter names for unsigned types
49 |     typedef uint8_t byte; ///< unsigned int type of exactly 8 bit
50 |     typedef unsigned short ushort;
51 |     typedef unsigned int uint;
52 |     typedef unsigned long ulong;
53 | 
54 |     // Shorter names for fixed width types
55 |     typedef int8_t int8;
56 |     typedef int16_t int16;
57 |     typedef int32_t int32;
58 |     typedef int64_t int64;
59 | 
60 |     typedef uint8_t uint8;
61 |     typedef uint16_t uint16;
62 |     typedef uint32_t uint32;
63 |     typedef uint64_t uint64;
64 | 
65 | }
66 | 
67 | // all of these can be writen like [[gnu::unused]] but kdevelop will not recognize them then
68 | /** 
69 |  * @def XERUS_force_inline 
70 |  * @brief Collection of attributes to force gcc to inline a specific function.
71 |  */
72 | #if defined(__clang__)
73 | 	#define XERUS_force_inline  inline
74 | #else
75 | 	#define XERUS_force_inline  inline __attribute__((always_inline, gnu_inline))
76 | #endif
77 | 
78 | #define XERUS_warn_unused	__attribute__((warn_unused_result))
79 | 


--------------------------------------------------------------------------------
/include/xerus/misc/stringUtilities.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 |  
20 | /**
21 |  * @file
22 |  * @brief Header file for some elementary string manipulation routines.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <string>
28 | #include <vector>
29 | 
30 | #include "standard.h"
31 | 
32 | namespace xerus {
33 | 	namespace misc {
34 | 		/// @brief Demangles the function and class names created by gcc into a more readable format.
35 | 		std::string XERUS_warn_unused demangle_cxa(const std::string& _cxa);
36 | 
37 | 		/// @brief Resolves 'folder/..' occurences in pathnames.
38 | 		std::string XERUS_warn_unused normalize_pathname(const std::string& _name);
39 | 
40 | 		///@brief: Explodes a string at positions indicated by _delim.
41 | 		std::vector<std::string> explode(const std::string& _string, const char _delim);
42 | 
43 | 		///@brief: Replaces all occurences of _search in _string by _replace.
44 | 		void replace(std::string& _string, const std::string& _search, const std::string& _replace);
45 | 		
46 | 		///@brief: Removes all leading and trailing whitespaces from _string.
47 | 		std::string XERUS_warn_unused trim(const std::string& _string, const std::string& whitespace = " \t\n\r\v");
48 | 
49 | 		///@brief: Removes all leading and trailing whitespaces from _string, and reduces all double whitespaces to one.
50 | 		std::string XERUS_warn_unused reduce(const std::string& _string, const std::string& whitespace = " \t\n\r\v", const std::string& fill = " ");
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/include/xerus/misc/timeMeasure.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for basic time measurement functionality.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "standard.h"
28 | 
29 | namespace xerus {
30 |     namespace misc {
31 | 
32 |         ///@brief: Returns the time since epoche in microseconds.
33 |         size_t uTime();
34 | 
35 |         ///@brief: Returns the time since epoche in milliseconds.
36 |         size_t mTime();
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/include/xerus/sparseTimesFullContraction.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for sparse matrix times dense matrix wrapper functions.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include <map>
28 | 
29 | namespace xerus {
30 |     
31 |     // - - - - - - - - - - - - - - - - - - - - - - - - - Mix to Full - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
32 |     void matrix_matrix_product( double* const _C,
33 |                                 const size_t _leftDim,
34 |                                 const size_t _rightDim,
35 |                                 const double _alpha,
36 |                                 const std::map<size_t, double>& _A,
37 |                                 const bool _transposeA,
38 |                                 const size_t _midDim,
39 |                                 const double* const _B,
40 |                                 const bool _transposeB);
41 |     
42 |     void matrix_matrix_product( double* const _C,
43 |                                 const size_t _leftDim,
44 |                                 const size_t _rightDim,
45 |                                 const double _alpha,
46 |                                 const double* const _A,
47 |                                 const bool _transposeA,
48 |                                 const size_t _midDim,
49 |                                 const std::map<size_t, double>& _B,
50 |                                 const bool _transposeB);
51 |     
52 |     
53 |     // - - - - - - - - - - - - - - - - - - - - - - - - - Mix to Sparse - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
54 |     void matrix_matrix_product( std::map<size_t, double>& _C,
55 |                                 const size_t _leftDim,
56 |                                 const size_t _rightDim,
57 |                                 const double _alpha,
58 |                                 const std::map<size_t, double>& _A,
59 |                                 const bool _transposeA,
60 |                                 const size_t _midDim,
61 |                                 const double* const _B,
62 |                                 const bool _transposeB);
63 |     
64 |     void matrix_matrix_product( std::map<size_t, double>& _C,
65 |                                 const size_t _leftDim,
66 |                                 const size_t _rightDim,
67 |                                 const double _alpha,
68 |                                 const double* const _A,
69 |                                 const bool _transposeA,
70 |                                 const size_t _midDim,
71 |                                 const std::map<size_t, double>& _B,
72 |                                 const bool _transposeB);
73 | }
74 | 


--------------------------------------------------------------------------------
/include/xerus/tensorLogger.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file that defines the logging behaviour of the internal debug log-levels used in the library.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "misc/namedLogger.h"
28 | 
29 | XERUS_SET_LOGGING(ContractionDebug, xerus::misc::internal::LOGGING_ON_ERROR)
30 | XERUS_SET_LOGGING(TNContract, xerus::misc::internal::LOGGING_ON_ERROR)
31 | XERUS_SET_LOGGING(TensorAssignment, xerus::misc::internal::LOGGING_ON_ERROR)
32 | XERUS_SET_LOGGING(ALS, xerus::misc::internal::LOGGING_ON_ERROR)
33 | XERUS_SET_LOGGING(unit_test, xerus::misc::internal::LOGGING_ON_ERROR)
34 | XERUS_SET_LOGGING(unit_tests, xerus::misc::internal::LOGGING_ON_ERROR)
35 | XERUS_SET_LOGGING(largestEntry, xerus::misc::internal::LOGGING_ON_ERROR)
36 | XERUS_SET_LOGGING(pydebug, xerus::misc::internal::LOGGING_ON_ERROR)
37 | // XERUS_SET_LOGGING(ADF, xerus::misc::internal::LOGGING_ON_ERROR)
38 | /* */
39 | 


--------------------------------------------------------------------------------
/include/xerus/ttStack.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Header file for the TTStack class.
23 |  */
24 | 
25 | #pragma once
26 | 
27 | #include "misc/check.h"
28 | 
29 | #include "tensorNetwork.h"
30 | #include "indexedTensorMoveable.h"
31 | 
32 | namespace xerus {
33 | 	template<bool isOperator> class TTNetwork;
34 | 	
35 | 	namespace internal {
36 | 		template<bool isOperator>
37 | 		///@brief Internal class used to represent stacks of (possibly multiply) applications of TTOperators to either a TTTensor or TTOperator.
38 | 		class TTStack final : public TensorNetwork {
39 | 		public:
40 | 			///@brief The number of external links in each node, i.e. one for TTTensors and two for TTOperators.
41 | 			static constexpr const size_t N = isOperator?2:1;
42 | 		
43 | 			const bool cannonicalization_required;
44 | 			
45 | 			const size_t futureCorePosition;
46 | 			
47 | 			explicit TTStack(const bool _canno, const size_t _corePos = 0);
48 | 			
49 | 			TTStack(const TTStack&  _other) = default;
50 | 			
51 | 			TTStack(      TTStack&& _other) = default;
52 | 			
53 | 			virtual TensorNetwork* get_copy() const override;
54 | 			
55 | 			TTStack& operator= (const TTStack&  _other) = delete;
56 | 			
57 | 			TTStack& operator= (      TTStack&& _other) = delete;
58 | 			
59 | 			explicit operator TTNetwork<isOperator>();
60 | 			
61 | 			virtual void operator*=(const value_t _factor) override;
62 | 			
63 | 			virtual void operator/=(const value_t _divisor) override;
64 | 			
65 | 			
66 | 			/*- - - - - - - - - - - - - - - - - - - - - - - - - - Operator specializations - - - - - - - - - - - - - - - - - - - - - - - - - - */
67 | 			virtual void specialized_evaluation(IndexedTensorWritable<TensorNetwork>&& , IndexedTensorReadOnly<TensorNetwork>&&) override;
68 | 			
69 | 			virtual bool specialized_contraction(std::unique_ptr<IndexedTensorMoveable<TensorNetwork>>& _out, IndexedTensorReadOnly<TensorNetwork>&& _me, IndexedTensorReadOnly<TensorNetwork>&& _other) const override;
70 | 			
71 | 			virtual bool specialized_sum(std::unique_ptr<IndexedTensorMoveable<TensorNetwork>>& _out, IndexedTensorReadOnly<TensorNetwork>&& _me, IndexedTensorReadOnly<TensorNetwork>&& _other) const override;
72 | 			
73 | 			static void contract_stack(IndexedTensorWritable<TensorNetwork>&& _me);
74 | 			
75 | 			virtual value_t frob_norm() const override;
76 | 		};
77 | 	}
78 | }
79 | 


--------------------------------------------------------------------------------
/makeIncludes/general.mk:
--------------------------------------------------------------------------------
 1 | # Sets: CXX, CALLSTACK_LIBS, LOCAL_HEADERS, LOCAL_HPP, TEST_HXX
 2 | # Uses: USE_CLANG, 
 3 | 
 4 | # Set Compiler used
 5 | ifneq (,$(findstring clang, $(CXX)))
 6 | 	USE_CLANG = true
 7 | endif
 8 | 
 9 | ifneq (,$(findstring icpc, $(CXX)))
10 | 	USE_ICC = true
11 | endif
12 | 
13 | ifneq (,$(findstring icc, $(CXX)))
14 | 	USE_ICC = true
15 | endif
16 | 
17 | ifneq (,$(findstring g++, $(CXX)))
18 | 	ifndef USE_CLANG
19 | 		USE_GCC = true
20 | 	endif
21 | endif
22 | 
23 | # include fancy_callstack specific libraries (binutils + dependencies)
24 | ifdef XERUS_NO_FANCY_CALLSTACK
25 | 	CALLSTACK_LIBS =
26 | 	DEBUG += -D XERUS_NO_FANCY_CALLSTACK
27 | else
28 | 	CALLSTACK_LIBS = -lbfd -liberty -lz -ldl 
29 | endif
30 | 
31 | 
32 | # Create list of local header files
33 | LOCAL_HEADERS =  $(wildcard *.h)
34 | LOCAL_HEADERS += $(wildcard */*.h)
35 | LOCAL_HEADERS += $(wildcard */*/*.h)
36 | 
37 | # Create list of local .hpp files
38 | LOCAL_HPP = $(wildcard *.hpp)
39 | LOCAL_HPP += $(wildcard */*.hpp)
40 | LOCAL_HPP += $(wildcard */*/*.hpp)
41 | 
42 | # Create list of local .hxx files
43 | LOCAL_HXX = $(wildcard *.hxx)
44 | LOCAL_HXX += $(wildcard */*.hxx)
45 | LOCAL_HXX += $(wildcard */*/*.hxx)
46 | 


--------------------------------------------------------------------------------
/src/docHelper/findDoxytag.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <fstream>
 3 | #include <string>
 4 | #include <vector>
 5 | #include <boost/algorithm/string.hpp>
 6 | 
 7 | int main(int argc, char *argv[]) {
 8 | 	if (argc < 2) {
 9 | 		std::cerr << "### no argument given to find the tag for..." << std::endl;
10 | 		return 1;
11 | 	}
12 | 	
13 | 	std::string memberName(argv[1]);
14 | 	std::ifstream inFile("xerus.tags");
15 | 	std::string line;
16 | 	std::size_t jumpSize = 100;
17 | 	// seek rough position
18 | 	auto lastPos = inFile.tellg();
19 | 	while (!inFile.eof()) {
20 | 		lastPos = inFile.tellg();
21 | 		for (size_t i=0; i<jumpSize; ++i) {
22 | 			std::getline(inFile, line);
23 | 		}
24 | 		std::vector<std::string> parts;
25 | 		boost::split(parts, line, boost::is_any_of("\t"));
26 | 		if (parts[0] == memberName) {
27 | 			std::cout << parts[1] << std::endl;
28 | 			return 0;
29 | 		}
30 | 		if (parts[0] > memberName) {
31 | 			inFile.seekg(lastPos);
32 | 			jumpSize /= 10;
33 | 			if (jumpSize == 1) {
34 | 				break;
35 | 			}
36 | 		}
37 | 	}
38 | 	if (inFile.eof()) {
39 | 		inFile.clear();
40 | 		inFile.seekg(lastPos);
41 | 	}
42 | 	
43 | 	while (std::getline(inFile, line)) {
44 | 		std::vector<std::string> parts;
45 | 		boost::split(parts, line, boost::is_any_of("\t"));
46 | 		if (parts[0] == memberName) {
47 | 			std::cout << parts[1] << std::endl;
48 | 			return 0;
49 | 		}
50 | 	}
51 | 	
52 | 	std::cerr << "### '" << memberName << "' not found in xerus.tags" << std::endl;
53 | 	return 2;
54 | }
55 | 


--------------------------------------------------------------------------------
/src/docHelper/parseDoxytags.cpp:
--------------------------------------------------------------------------------
 1 | #include <boost/property_tree/ptree.hpp>
 2 | #include <boost/property_tree/xml_parser.hpp>
 3 | #include <boost/algorithm/string/replace.hpp>
 4 | #include <iostream>
 5 | #include <fstream>
 6 | #include <string>
 7 | #include <map>
 8 | 
 9 | using boost::property_tree::ptree;
10 | 
11 | int main() {
12 | 	ptree pt;
13 | 	read_xml("xerus.tagfile", pt);
14 | 	
15 | 	std::map<std::string, std::string> tags;
16 | 	for (const auto &compound : pt.get_child("tagfile")) {
17 | 		std::string currNamespace = "";
18 | 		if (compound.first != "compound") {
19 | 			std::cout << "*** skipping " << compound.first << " tag" << std::endl;
20 | 			continue;
21 | 		}
22 | 		std::string kind = compound.second.get<std::string>("<xmlattr>.kind", "N/A");
23 | 		if (kind == "page") {
24 | 			continue;
25 | 		}
26 | 		if (kind == "class" || kind == "struct" || kind == "namespace") {
27 | 			currNamespace = compound.second.get<std::string>("name");
28 | 		}
29 | 		
30 | 		for (const auto &subc : compound.second) {
31 | 			// we are looking for namespaces (in order! -.-) and members
32 | 			if (subc.first == "namespace") {
33 | 				currNamespace = subc.second.get<std::string>("");
34 | 			} else if (subc.first == "member") {
35 | 				std::string name = subc.second.get<std::string>("name");
36 | 				std::string subkind = subc.second.get<std::string>("<xmlattr>.kind", "N/A");
37 | 				std::string anchorfile = subc.second.get<std::string>("anchorfile");
38 | 				std::string anchor = subc.second.get<std::string>("anchor");
39 | 				std::string args = subc.second.get<std::string>("arglist");
40 | 				if (currNamespace!= "" && subkind != "define") {
41 | 					name = currNamespace+"::"+name;
42 | 				}
43 | 				boost::replace_all(name, " ", "");
44 | 				tags.insert({name, anchorfile + '#' + anchor});
45 | 			} else {
46 | // 				std::cout << "* skipping " << subc.first << std::endl;
47 | 			}
48 | 		}
49 | 	}
50 | 	
51 | 	std::ofstream outFile("xerus.tags");
52 | 	for (const auto &t : tags) {
53 | 		outFile << t.first << "\t/doxygen/" << t.second << '\n';
54 | 	}
55 | 	
56 | 	std::cout << "### found " << tags.size() << " unique tags in xerus.tagfile created by doxygen." << std::endl;
57 | }
58 | 


--------------------------------------------------------------------------------
/src/unitTests/cg.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | 
23 | #include "../../include/xerus/test/test.h"
24 | using namespace xerus;
25 | 
26 | // UNIT_TEST(algorithms, cg,
27 | // 	std::uniform_real_distribution<value_t> dist (0.0, 1.0);
28 | //     
29 | //     Index i,j,k;
30 | //     
31 | //     TTTensor X = TTTensor::random({10,10,10,10}, {4,4,4}, dist);
32 | // 	TTTensor B = TTTensor::random({10,10,10,10}, {2,2,2}, dist);
33 | // 	TTOperator A = TTOperator::random({10,10,10,10,10,10,10,10}, {2,2,2}, dist);
34 | // 	
35 | // // 	A(i/2,j/2) = A(k/2,i/2) * A(k/2,j/2);
36 | // // 	B(i&0) = A(i/2,j/2) * B(j&0);
37 | // 
38 | // 	PerformanceData pdata(true);
39 | // 	GeometricCGVariant cg(GeometricCG);
40 | // // 	cg.assumeSymmetricPositiveDefiniteOperator = true;
41 | // 	cg.retraction = ALSRetractionI;
42 | // // 	cg.restartInterval = 20;
43 | // 	cg.convergenceEpsilon = 0;
44 | // 	
45 | // 	cg(A, X, B, pdata);
46 | // 	
47 | // 	SteepestDescentVariant alsGrad(ALSRetractionII);
48 | // 	alsGrad.printProgress = true;
49 | // 	alsGrad.assumeSymmetricPositiveDefiniteOperator = true;
50 | // 	
51 | // 	alsGrad(A, X, B);
52 | // )
53 | 
54 | 


--------------------------------------------------------------------------------
/src/unitTests/decompositionAls.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include <xerus.h>
22 | 
23 | #include "../../include/xerus/test/test.h"
24 | 
25 | using namespace xerus;
26 | 
27 | static misc::UnitTest decomp_als("ALS", "decomposition_als", [](){
28 | 	xerus::Index i,j,k;
29 | 	
30 | 	const size_t d = 14;
31 | 	const size_t n = 2;
32 | 
33 | 	const std::vector<size_t> stateDims(d, n);
34 | 	
35 |     xerus::TTTensor TTB = xerus::TTTensor::random(stateDims, 4);
36 | 	Tensor B(TTB);
37 | 	
38 | 	xerus::TTTensor X = xerus::TTTensor::random(stateDims, 4);
39 | 	
40 | 	xerus::decomposition_als(X, B);
41 | 	
42 | 	TEST(frob_norm(X(i&0)-B(i&0)) < 1e-8);
43 | });
44 | 


--------------------------------------------------------------------------------
/src/unitTests/fileIO.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | #include "../../include/xerus/test/test.h"
23 | #include "../../include/xerus/misc/internal.h"
24 | 
25 | using namespace xerus;
26 | 
27 | 
28 | static misc::UnitTest tensor_rw("Tensor", "read_write_file", [](){
29 | 	Tensor A = Tensor::random({12,13,14});
30 | 	
31 | 	misc::save_to_file(A, "test.dat", misc::FileFormat::TSV);
32 | 	Tensor Ab = misc::load_from_file<Tensor>("test.dat");
33 | 	MTEST(approx_equal(A, Ab), "dense tsv " << frob_norm(A-Ab));
34 | 	
35 | 	misc::save_to_file(A, "test.dat", misc::FileFormat::BINARY);
36 | 	Ab = misc::load_from_file<Tensor>("test.dat");
37 | 	MTEST(approx_equal(A, Ab), "dense bin " << frob_norm(A-Ab));
38 | 	
39 | 	Tensor S({100,234,567}, Tensor::Representation::Sparse);
40 | 	S[{5,7,99}] = 1; S[{80,123,5}] = 6; S[{1,2,3}] = 4; S[{99,233,566}] = 5;
41 | 	S[{12,12,12}] = 8; S[{15,15,15}] = 7; S[{99,99,99}] = 3; S[{65,65,65}] = 2;
42 | 	
43 | 	save_to_file(S, "test.dat", misc::FileFormat::BINARY);
44 | 	Ab = misc::load_from_file<Tensor>("test.dat");
45 | 	MTEST(frob_norm(S - Ab) < 1e-16, "sparse bin " << frob_norm(S-Ab));
46 | 	
47 | 	save_to_file(S, "test.dat", misc::FileFormat::TSV);
48 | 	Ab = misc::load_from_file<Tensor>("test.dat");
49 | 	TEST(Ab.is_sparse());
50 | 	MTEST(frob_norm(S - Ab) < 1e-16, "sparse tsv " << frob_norm(S-Ab));
51 | });
52 | 
53 | static misc::UnitTest tn_rw("TensorNetwork", "read_write_file", [](){
54 | 	Tensor A = Tensor::random({12,13,14});
55 | 	Tensor B = Tensor({12,13,14}, Tensor::Representation::Sparse);
56 | 	B[{1,1,1}] = 1; B[{2,3,4}] = 2; B[{7,10,3}] = 3; B[{5,12,13}] = 4; B[{8,7,6}] = 5;
57 | 	Tensor C = Tensor::random({12,13,14});
58 | 	Index i,j,k,l,m,n;
59 | 	TensorNetwork T;
60 | 	T(k,l,n) = A(i,j,k) * B(i,l,m) * C(n,j,m);
61 | 	save_to_file(T, "test.dat", misc::FileFormat::TSV);
62 | 	TensorNetwork Tb = misc::load_from_file<TensorNetwork>("test.dat");
63 | 	MTEST(T.dimensions == Tb.dimensions, T.dimensions << " vs " << Tb.dimensions);
64 | 	Tb.require_valid_network();
65 | 	MTEST(frob_norm(T(i&0)-Tb(i&0))/frob_norm(T) < 6e-16, frob_norm(T(i&0)-Tb(i&0))/frob_norm(T));
66 | 	
67 | 	save_to_file(T, "test.dat", misc::FileFormat::BINARY);
68 | 	Tb = misc::load_from_file<TensorNetwork>("test.dat");
69 | 	MTEST(T.dimensions == Tb.dimensions, T.dimensions << " vs " << Tb.dimensions);
70 | 	Tb.require_valid_network();
71 | 	MTEST(frob_norm(T(i&0)-Tb(i&0))/frob_norm(T) < 6e-16, frob_norm(T(i&0)-Tb(i&0))/frob_norm(T));
72 | });
73 | 
74 | 
75 | static misc::UnitTest tt_rw("TT", "read_write_file", [](){
76 | 	TTTensor A = TTTensor::random({7,8,9,10}, {2,2,2});
77 | 	
78 | 	misc::save_to_file(A, "test.dat");
79 | 	
80 | 	FAILTEST(TensorNetwork Tb = misc::load_from_file<TensorNetwork>("test.dat"));
81 | 	TTTensor Ab = misc::load_from_file<TTTensor>("test.dat");
82 | 	Index i;
83 | 	Ab.require_correct_format();
84 | 	MTEST(Ab.canonicalized && Ab.corePosition == 0, Ab.canonicalized << " " << Ab.corePosition);
85 | 	MTEST(A.dimensions == Ab.dimensions, A.dimensions << " vs " << Ab.dimensions);
86 | 	MTEST(frob_norm(A(i&0)-Ab(i&0))/frob_norm(A) < 6e-16, frob_norm(A(i&0)-Ab(i&0))/frob_norm(A));
87 | });
88 | 


--------------------------------------------------------------------------------
/src/unitTests/fullTensor_add_sub.cxx:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | // compare_memory_to_vector\(([a-zA-Z0-9]*)\.data\.get\(\), ?(\{[0-9, +\*]*\})\)
 21 | // \1.compare_to_data(\2)
 22 | 
 23 | 
 24 | #include<xerus.h>
 25 | 
 26 | #include "../../include/xerus/test/test.h"
 27 | using namespace xerus;
 28 | 
 29 | static misc::UnitTest tensor_sum_mat2("Tensor", "sum_matrix_2x2", [](){
 30 |     Tensor res({2,2});
 31 |     Tensor B({2,2});
 32 |     Tensor C({2,2});
 33 | 
 34 |     Index i, J;
 35 |     
 36 |     B[{0,0}]=1;
 37 |     B[{0,1}]=2;
 38 |     B[{1,0}]=3;
 39 |     B[{1,1}]=4;
 40 |     
 41 |     C[{0,0}]=5;
 42 |     C[{0,1}]=6;
 43 |     C[{1,0}]=7;
 44 |     C[{1,1}]=8;
 45 |     
 46 |     res(i,J) = B(i,J) + C(i,J);
 47 |     TEST(approx_entrywise_equal(res, {6,8,10,12}));
 48 |     res(i,J) = B(i,J) + C(J,i);
 49 |     TEST(approx_entrywise_equal(res, {6,9,9,12}));
 50 | });
 51 |  
 52 | static misc::UnitTest tensor_sum_eq("Tensor", "sum_lhs_equals_rhs", [](){
 53 |     Tensor B({2,2});
 54 |     Tensor C({2,2});
 55 | 
 56 |     Index i, J;
 57 |     
 58 |     B[{0,0}]=1;
 59 |     B[{0,1}]=2;
 60 |     B[{1,0}]=3;
 61 |     B[{1,1}]=4;
 62 |     
 63 |     C[{0,0}]=5;
 64 |     C[{0,1}]=6;
 65 |     C[{1,0}]=7;
 66 |     C[{1,1}]=8;
 67 |     
 68 |     B(i,J) = B(i,J) + C(i,J);
 69 | 	TEST(approx_entrywise_equal(B, {6,8,10,12}));
 70 |     B(i,J) = B(i,J) + B(J,i);
 71 |     TEST(approx_entrywise_equal(B, {12,18,18,24}));
 72 | });
 73 | 
 74 | static misc::UnitTest tensor_sum_mat1000("Tensor", "sum_matrix_1000x1000", [](){
 75 |     Tensor res({1024,1024});
 76 |     Tensor A({1024,1024}, [](const std::vector<size_t> &_idx) {
 77 | 		return double(_idx[0] + _idx[1]);
 78 | 	});
 79 |     Tensor B({1024,1024}, [](const std::vector<size_t> &_idx) {
 80 | 		return double(_idx[0] * _idx[1]);
 81 | 	});
 82 |     Tensor C({1024,1024}, [](const std::vector<size_t> &_idx) {
 83 | 		return double(_idx[0] + _idx[1] + _idx[0] * _idx[1]);
 84 | 	});
 85 | 
 86 |     Index i, J;
 87 |     
 88 |     res(i,J) = A(i,J) + B(i,J);
 89 |     TEST(approx_entrywise_equal(res, C, 1e-14));
 90 |     res(J,i) = A(J,i) + B(i,J);
 91 |     TEST(approx_entrywise_equal(res, C, 1e-14));
 92 | });
 93 | 
 94 | static misc::UnitTest tensor_dyadic("Tensor", "sum_dyadic", [](){
 95 |     Tensor res({2,2});
 96 |     Tensor B({2});
 97 |     Tensor C({2});
 98 | 
 99 |     Index i, J, K;
100 |     
101 |     B[0]=1;
102 |     B[1]=2;
103 |     
104 |     C[0]=5;
105 |     C[1]=9;
106 |     
107 |     FAILTEST(res(i,J) = B(i) + C(J));
108 | //     TEST(approx_entrywise_equal(res, {6,10,7,11}));
109 | });
110 | 
111 | static misc::UnitTest tensor_sum_threefold("Tensor", "sum_threefold_sum", [](){
112 |     Tensor res({2});
113 |     Tensor B({2});
114 |     Tensor C({2});
115 |     Tensor D({2});
116 | 
117 |     Index i, J, K;
118 |     
119 |     B[0]=1;
120 |     B[1]=2;
121 |     
122 |     C[0]=5;
123 |     C[1]=9;
124 |     
125 |     D[0]=7;
126 |     D[1]=13;
127 |     
128 |     res(i) = B(i) + C(i) + D(i);
129 |     TEST(approx_entrywise_equal(res, {13,24}));
130 | });
131 | 


--------------------------------------------------------------------------------
/src/unitTests/fullTensor_arithmetic.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | #include "../../include/xerus/test/test.h"
23 | using namespace xerus;
24 | 
25 | static misc::UnitTest tensor_arith_neg("Tensor", "Arithmetic_Negatives", [](){
26 |     Tensor A({2,2,2});
27 |     Tensor B({2,2});
28 |     Tensor B2({3,3});
29 |     Tensor B3({3,2});
30 |     Tensor B4({2,3});
31 |     Tensor B5({2,2,2});
32 |     Tensor C({2});
33 |     
34 |     Index i,j,k;
35 | 
36 |     FAILTEST(C(i) = B(i,j) * B2(j,j));
37 |     FAILTEST(C(i) = B(i,j) * B3(j,j));
38 |     FAILTEST(C(i) = B(i,j) * B4(j,j));
39 |     FAILTEST(C(i) = B(i,j) * B5(j,j,j));
40 |     FAILTEST(B(i,j) = B(i,j) + B2(j,j));
41 |     FAILTEST(B(i,j) = B(i,j) + B3(j,j));
42 |     FAILTEST(B(i,j) = B(i,j) + B4(j,j));
43 |     FAILTEST(B(i,j) = B(i,j) + B5(j,j,j));
44 | });
45 | 
46 | static misc::UnitTest tensor_triple_idx("Tensor", "triple_indices", [](){
47 | 	Tensor A;
48 | 	Tensor B;
49 | 	Tensor C;
50 | 	Tensor D;
51 | 	Tensor F;
52 | 	Tensor E0;
53 | 	Tensor E1;
54 | 	Tensor E2;
55 | 	Index i1,i2,i3,i4;
56 | 	
57 | 	FAILTEST(E0()   = A(i1,i1,i2/3)*B(i2/2,i2));
58 | 	FAILTEST(E1(i2) = A(i1,i1,i2)*B(i2,i2));
59 | 	FAILTEST(E0()   = A(i1,i2,i2)*B(i2,i1));
60 | 	FAILTEST(E1(i2) = A(i1,i2,i2)*B(i2,i1));
61 | 	FAILTEST(E0()   = A(i2,i2,i2)*B(i1,i1));
62 | 	FAILTEST(E1(i2) = A(i2,i2,i2)*B(i1,i1));
63 | 	FAILTEST(E0()   = A(i1,i2,i2)*B(i1,i3)*C(i3,i2));
64 | // 	FAILTEST(E1(i2) = A(i1,i2,i2)*B(i1,i3)*C(i3,i2)); //FEATURE
65 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i3,i2));
66 | // 	FAILTEST(E2(i1,i2) = B(i1,i2)*C(i2,i3)*D(i3,i2)); //FEATURE
67 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i1,i2));
68 | // 	FAILTEST(E2(i2,i3) = B(i1,i2)*C(i2,i3)*D(i1,i2)); //FEATURE
69 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i3,i4)*F(i4,i2));
70 | // 	FAILTEST(E2(i1,i2) = B(i1,i2)*C(i2,i3)*D(i3,i4)*F(i4,i2)); //FEATURE
71 | });
72 | 
73 |     
74 | 


--------------------------------------------------------------------------------
/src/unitTests/fullTensor_factor.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | 
23 | #include "../../include/xerus/test/test.h"
24 | using namespace xerus;
25 | 
26 | static misc::UnitTest tensor_factors("Tensor", "Factors", [](){
27 |     Tensor A = Tensor::random({2,7,5,5,2,7});
28 |     Tensor B = Tensor::random({2,7,5,5,2,7});
29 |     Tensor A3 = 3*A;
30 |     Tensor B7 = 7*B;
31 | 	TEST(!A.has_factor());
32 | 	TEST(!B.has_factor());
33 | 	TEST(A3.has_factor());
34 | 	TEST(B7.has_factor());
35 | 	
36 |     Tensor Q;
37 |     Tensor R;
38 |     Tensor res1;
39 |     Tensor res2;
40 |     Tensor res3;
41 |     Tensor res4;
42 |     
43 |     Index i, j, k, l, m, n, o, p, r, s;
44 |     
45 |     (res1(i,j,k,o), res2(o,p), res3(p,l,m,n)) = SVD(3*A(i,j,k,l,m,n));
46 |     res4(i,j,k,l,m,n) = 3.7*res1(i,j,k,o)*(res2(o,p)/3.7)*res3(p,l,m,n);
47 |     TEST(approx_equal(res4, A3, 1e-11));
48 |     
49 |     (Q(i,j,k,l), R(l,m,n,r)) = QR(B7(i,j,k,m,n,r));
50 |     res4(i,j,k,m,n,r) = (Q(i,j,k,o)/12.5)*(12.5*R(o,m,n,r)/7);
51 |     TEST(approx_equal(res4, B, 1e-12));
52 | });
53 | 
54 | static misc::UnitTest tensor_value_t("Tensor", "value_t_Product", [](){
55 |     Tensor A({4,2,2,7});
56 |     Tensor B;
57 |     Tensor C;
58 |     Tensor D;
59 |     for(size_t i = 0; i < A.size; ++i) {
60 |         A[i] = 73;
61 |     }
62 |     
63 |     Index j;
64 |     
65 |     B(j&0) = A(j&0)*2.0;
66 |     C(j&0) = 3*A(j&0);
67 |     D(j&0) = A(j&0)/73.0;
68 |     A(j&0) = A(j&0)/2;
69 |     
70 |     TEST(approx_entrywise_equal(B, std::vector<value_t>(A.size, 146)));
71 |     TEST(approx_entrywise_equal(C, std::vector<value_t>(A.size, 219)));
72 |     TEST(approx_entrywise_equal(D, std::vector<value_t>(A.size, 1)));
73 |     TEST(approx_entrywise_equal(A, std::vector<value_t>(A.size, 36.5)));
74 | });
75 | 


--------------------------------------------------------------------------------
/src/unitTests/indices.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | 
23 | #include "../../include/xerus/test/test.h"
24 | #include "../../include/xerus/misc/internal.h"
25 | using namespace xerus;
26 | 
27 | static misc::UnitTest failtest("Index", "invalid_spans", [](){
28 | #ifdef XERUS_DISABLE_RUNTIME_CHECKS
29 | 	LOG(warning, "failtests skipped due to XERUS_DISABLE_RUNTIME_CHECKS");
30 | #else
31 | 	Index i,j;
32 | 	Tensor c;
33 | 	Tensor A = Tensor::random({10,10});
34 | 	Tensor b = Tensor::random({10});
35 | 	
36 | 	try {
37 | 		A(i,j^2) = A(j^2,i);
38 | 		MTEST(false, "A(j^2,i) did not throw!");
39 | 	} catch (misc::generic_error &_e) {
40 | 		TEST(true);
41 | 	} catch (...) {
42 | 		MTEST(false, "threw a wrong exception class!");
43 | 	}
44 | 	
45 | 	try {
46 | 		A(i,j) = A(j,i&0);
47 | 		MTEST(false, "A(j^2,i) did not throw!");
48 | 	} catch (misc::generic_error &_e) {
49 | 		TEST(true);
50 | 	} catch (...) {
51 | 		MTEST(false, "threw a wrong exception class!");
52 | 	}
53 | 	
54 | 	try {
55 | 		A(i,j) = A(j,i/1);
56 | 		MTEST(false, "A(j^2,i) did not throw!");
57 | 	} catch (misc::generic_error &_e) {
58 | 		TEST(true);
59 | 	} catch (...) {
60 | 		MTEST(false, "threw a wrong exception class!");
61 | 	}
62 | 	
63 | 	try {
64 | 		A(i,j) = A(j,i/3);
65 | 		MTEST(false, "A(j^2,i) did not throw!");
66 | 	} catch (misc::generic_error &_e) {
67 | 		TEST(true);
68 | 	} catch (...) {
69 | 		MTEST(false, "threw a wrong exception class!");
70 | 	}
71 | 	
72 | 	try {
73 | 		c(j) = A(i,j) * b(j);
74 | 		MTEST(false, "c(j)=... did not throw!");
75 | 	} catch (misc::generic_error &_e) {
76 | 		TEST(true);
77 | 	} catch (...) {
78 | 		MTEST(false, "threw a wrong exception class!");
79 | 	}
80 | #endif
81 | });
82 | 


--------------------------------------------------------------------------------
/src/unitTests/sparseTensor_add_sub_cpy.cxx:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | 
 21 | #include<xerus.h>
 22 | 
 23 | #include "../../include/xerus/test/test.h"
 24 | using namespace xerus;
 25 | 
 26 | static misc::UnitTest sparse_sum2("SparseTensor", "sum_matrix_2x2", [](){
 27 |     Tensor res({2,2}, Tensor::Representation::Sparse);
 28 |     Tensor B({2,2}, Tensor::Representation::Sparse);
 29 |     Tensor C({2,2}, Tensor::Representation::Sparse);
 30 | 
 31 |     Index i, J;
 32 |     
 33 |     B[{0,0}]=1;
 34 |     B[{0,1}]=2;
 35 |     B[{1,0}]=3;
 36 |     B[{1,1}]=4;
 37 |     
 38 |     C[{0,0}]=5;
 39 |     C[{0,1}]=6;
 40 |     C[{1,0}]=7;
 41 |     C[{1,1}]=8;
 42 |     
 43 | 	B.use_sparse_representation();
 44 | 	C.use_sparse_representation();
 45 | 	
 46 |     res(i,J) = B(i,J) + C(i,J);
 47 |     TEST(approx_entrywise_equal(res, {6,8,10,12}));
 48 |     res(i,J) = B(i,J) + C(J,i);
 49 |     TEST(approx_entrywise_equal(res, {6,9,9,12}));
 50 | });
 51 |  
 52 | static misc::UnitTest sparse_sum_eq("SparseTensor", "sum_lhs_equals_rhs", [](){
 53 |     Tensor B({2,2}, Tensor::Representation::Sparse);
 54 |     Tensor C({2,2}, Tensor::Representation::Sparse);
 55 | 
 56 |     Index i, J;
 57 |     
 58 |     B[{0,0}]=1;
 59 |     B[{0,1}]=2;
 60 |     B[{1,0}]=3;
 61 |     B[{1,1}]=4;
 62 |     
 63 |     C[{0,0}]=5;
 64 |     C[{0,1}]=6;
 65 |     C[{1,0}]=7;
 66 |     C[{1,1}]=8;
 67 |     
 68 | 	B.use_sparse_representation();
 69 | 	C.use_sparse_representation();
 70 |     B(i,J) = B(i,J) + C(i,J);
 71 | 	TEST(approx_entrywise_equal(B, {6,8,10,12}));
 72 |     B(i,J) = B(i,J) + B(J,i);
 73 |     TEST(approx_entrywise_equal(B, {12,18,18,24}));
 74 | });
 75 | 
 76 | 
 77 | static misc::UnitTest sparse_dyadicsum("SparseTensor", "sum_dyadic", [](){
 78 |     Tensor res({2,2}, Tensor::Representation::Sparse);
 79 |     Tensor B({2}, Tensor::Representation::Sparse);
 80 |     Tensor C({2}, Tensor::Representation::Sparse);
 81 | 
 82 |     Index i, J, K;
 83 |     
 84 |     FAILTEST(res(i,J) = B(i) + C(J));
 85 | });
 86 | 
 87 | static misc::UnitTest sparse_sum_three("SparseTensor", "sum_threefold", [](){
 88 |     Tensor res({2}, Tensor::Representation::Sparse);
 89 |     Tensor B({2}, Tensor::Representation::Sparse);
 90 |     Tensor C({2}, Tensor::Representation::Sparse);
 91 |     Tensor D({2}, Tensor::Representation::Sparse);
 92 | 
 93 |     Index i, J, K;
 94 |     
 95 |     B[0]=1;
 96 |     B[1]=2;
 97 |     
 98 |     C[0]=5;
 99 |     C[1]=9;
100 |     
101 |     D[0]=7;
102 |     D[1]=13;
103 |     
104 | 	B.use_sparse_representation();
105 | 	C.use_sparse_representation();
106 | 	D.use_sparse_representation();
107 | 	
108 |     res(i) = B(i) + C(i) + D(i);
109 |     TEST(approx_entrywise_equal(res, {13,24}));
110 | });
111 | 


--------------------------------------------------------------------------------
/src/unitTests/sparseTensor_arithmetic_cpy.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | 
23 | #include "../../include/xerus/test/test.h"
24 | using namespace xerus;
25 | 
26 | static misc::UnitTest sparse_arith_neg("SparseTensor", "Arithmetic_Negatives", [](){
27 |     Tensor A({2,2,2}, Tensor::Representation::Sparse);
28 |     Tensor B({2,2}, Tensor::Representation::Sparse);
29 |     Tensor B2({3,3}, Tensor::Representation::Sparse);
30 |     Tensor B3({3,2}, Tensor::Representation::Sparse);
31 |     Tensor B4({2,3}, Tensor::Representation::Sparse);
32 |     Tensor B5({2,2,2}, Tensor::Representation::Sparse);
33 |     Tensor C({2}, Tensor::Representation::Sparse);
34 |     
35 |     Index i,j,k;
36 | 
37 |     FAILTEST(C(i) = B(i,j) * B2(j,j));
38 |     FAILTEST(C(i) = B(i,j) * B3(j,j));
39 |     FAILTEST(C(i) = B(i,j) * B4(j,j));
40 |     FAILTEST(C(i) = B(i,j) * B5(j,j,j));
41 |     FAILTEST(B(i,j) = B(i,j) + B2(j,j));
42 |     FAILTEST(B(i,j) = B(i,j) + B3(j,j));
43 |     FAILTEST(B(i,j) = B(i,j) + B4(j,j));
44 |     FAILTEST(B(i,j) = B(i,j) + B5(j,j,j));
45 | });
46 | 
47 | static misc::UnitTest sparse_tripleIdx("SparseTensor", "triple_indices", [](){
48 | 	Tensor A({1,1,1}, Tensor::Representation::Sparse);
49 | 	Tensor B({1,1}, Tensor::Representation::Sparse);
50 | 	Tensor C({1,1}, Tensor::Representation::Sparse);
51 | 	Tensor D({1,1}, Tensor::Representation::Sparse);
52 | 	Tensor F({1,1}, Tensor::Representation::Sparse);
53 | 	Tensor E0( Tensor::Representation::Sparse );
54 | 	Tensor E1({1}, Tensor::Representation::Sparse);
55 | 	Tensor E2({1}, Tensor::Representation::Sparse);
56 | 	Index i1,i2,i3,i4;
57 | 	
58 | 	FAILTEST(E0()   = A(i1,i1,i2)*B(i2,i2));
59 | 	FAILTEST(E1(i2) = A(i1,i1,i2)*B(i2,i2));
60 | 	FAILTEST(E0()   = A(i1,i2,i2)*B(i2,i1));
61 | 	FAILTEST(E1(i2) = A(i1,i2,i2)*B(i2,i1));
62 | 	FAILTEST(E0()   = A(i2,i2,i2)*B(i1,i1));
63 | 	FAILTEST(E1(i2) = A(i2,i2,i2)*B(i1,i1));
64 | 	FAILTEST(E0()   = A(i1,i2,i2)*B(i1,i3)*C(i3,i2));
65 | // 	FAILTEST(E1(i2) = A(i1,i2,i2)*B(i1,i3)*C(i3,i2)); //FEATURE
66 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i3,i2));
67 | // 	FAILTEST(E2(i1,i2) = B(i1,i2)*C(i2,i3)*D(i3,i2)); //FEATURE
68 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i1,i2));
69 | // 	FAILTEST(E2(i2,i3) = B(i1,i2)*C(i2,i3)*D(i1,i2)); //FEATURE
70 | 	FAILTEST(E0()      = B(i1,i2)*C(i2,i3)*D(i3,i4)*F(i4,i2));
71 | // 	FAILTEST(E2(i1,i2) = B(i1,i2)*C(i2,i3)*D(i3,i4)*F(i4,i2)); //FEATURE
72 | });
73 |     
74 | 


--------------------------------------------------------------------------------
/src/unitTests/tensorNetwork_element_access.cxx:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | 
 21 | #include <xerus.h>
 22 | 
 23 | #include "../../include/xerus/test/test.h"
 24 | 
 25 | using namespace xerus;
 26 | 
 27 | static misc::UnitTest tn_elem_access("TensorNetwork", "element_access", [](){
 28 |     Tensor A({1,2});
 29 |     Tensor B({2,3});
 30 |     TensorNetwork res;
 31 | 
 32 |     Index i,j,k,l;
 33 |     
 34 |     A[{0,0}] = 1;
 35 |     A[{0,1}] = 2;
 36 |     
 37 |     B[{0,0}] = 3;
 38 |     B[{0,1}] = 4;
 39 |     B[{0,2}] = 5;
 40 |     B[{1,0}] = 6;
 41 |     B[{1,1}] = 7;
 42 |     B[{1,2}] = 8;
 43 |     
 44 |     //No Index contracted
 45 |     res(i,j,k,l) = A(i,j) * B(k,l);
 46 |     std::vector<value_t> resX({3,4,5,6,7,8,6,8,10,12,14,16});
 47 |     for(size_t t = 0; t < misc::product(res.dimensions); ++t) {
 48 |         TEST(misc::approx_equal(res[t], resX[t]));
 49 |     }
 50 |     TEST(misc::approx_equal(res[{0,1,1,1}], 14.0));
 51 |     
 52 | 
 53 |     //One Index contracted
 54 |     res(k,i) = B(j,k) * A(i,j);
 55 |     
 56 |     TEST(misc::approx_equal(res[0], 15.0));
 57 |     TEST(misc::approx_equal(res[1], 18.0));
 58 |     TEST(misc::approx_equal(res[2], 21.0));
 59 |     TEST(misc::approx_equal(res[{0,0}], 15.0));
 60 |     TEST(misc::approx_equal(res[{1,0}], 18.0));
 61 |     TEST(misc::approx_equal(res[{2,0}], 21.0));
 62 | });
 63 | 
 64 | 
 65 | static misc::UnitTest tn_many_access("TensorNetwork", "many_element_access", [](){
 66 |     Tensor A({1,2});
 67 |     Tensor B({2,3});
 68 |     TensorNetwork res;
 69 | 
 70 |     Index i,j,k,l;
 71 |     
 72 |     A[{0,0}] = 1;
 73 |     A[{0,1}] = 2;
 74 |     
 75 |     B[{0,0}] = 3;
 76 |     B[{0,1}] = 4;
 77 |     B[{0,2}] = 5;
 78 |     B[{1,0}] = 6;
 79 |     B[{1,1}] = 7;
 80 |     B[{1,2}] = 8;
 81 |     
 82 |     //No Index contracted
 83 |     res(i,j,k,l) = A(i,j) * B(k,l);
 84 | 
 85 | 	SinglePointMeasurementSet measurments;
 86 | 	measurments.add({0,0,0,0}, 0);
 87 | 	measurments.add({0,0,0,1}, 0);
 88 | 	measurments.add({0,0,0,2}, 0);
 89 | 	measurments.add({0,0,1,0}, 0);
 90 | 	measurments.add({0,0,1,1}, 0);
 91 | 	measurments.add({0,0,1,2}, 0);
 92 | 	measurments.add({0,1,0,0}, 0);
 93 | 	measurments.add({0,1,0,1}, 0);
 94 | 	measurments.add({0,1,0,2}, 0);
 95 | 	measurments.add({0,1,1,0}, 0);
 96 | 	measurments.add({0,1,1,1}, 0);
 97 | 	measurments.add({0,1,1,2}, 0);
 98 | 	
 99 | 	measurments.measure(res);
100 | 	
101 | 	for(size_t m = 0; m < measurments.size(); ++m) {
102 | 		TEST(misc::approx_equal(measurments.measuredValues[m], res[measurments.positions[m]]));
103 |     }
104 | });
105 | 


--------------------------------------------------------------------------------
/src/unitTests/ttOther.cxx:
--------------------------------------------------------------------------------
 1 | #include<xerus.h>
 2 | 
 3 | #include "../../include/xerus/test/test.h"
 4 | using namespace xerus;
 5 | 
 6 | static misc::UnitTest tt_entryprod("TT", "entrywise_product", [](){
 7 | 	Index i,j,k;
 8 | 
 9 | 	TTTensor A = TTTensor::random(std::vector<size_t>(10,2), std::vector<size_t>(9,2));
10 | 	TTTensor B = TTTensor::random(std::vector<size_t>(10,2), std::vector<size_t>(9,2));
11 | 	
12 | 	Tensor Af(A);
13 | 	Tensor Bf(B);
14 | 	
15 | 	TTOperator Ao(Af);
16 | 	TTOperator Bo(Bf);
17 | 	
18 | 	TTTensor C = entrywise_product(A, B);
19 | 	TTOperator Co = entrywise_product(Ao, Bo);
20 | 	Tensor Cf = entrywise_product(Af, Bf);
21 | 	
22 | 	MTEST(frob_norm(Cf - Tensor(Co))/frob_norm(Cf) < 1e-13, frob_norm(Cf - Tensor(Co))/frob_norm(Cf));
23 | 	MTEST(frob_norm(Cf - Tensor(C))/frob_norm(Cf) < 1e-13, frob_norm(Cf - Tensor(C))/frob_norm(Cf));
24 | 	
25 | 	
26 | 	TTTensor D1 = entrywise_product(A, A);
27 | 	
28 | 	TTOperator Do1 = entrywise_product(Ao, Ao);
29 | 	
30 | 	Tensor Df = entrywise_product(Af, Af);
31 | 
32 | 	MTEST(approx_equal(Df, Tensor(D1), 1e-13), frob_norm(Df-Tensor(D1)));
33 | 	MTEST(approx_equal(Df, Tensor(Do1), 1e-13), frob_norm(Df- Tensor(Do1)));
34 | });
35 | 
36 | static misc::UnitTest tt_soft("TT", "soft_thresholding", [](){
37 | 	Index i,j,k;
38 | 
39 | 	TTTensor A = TTTensor::random(std::vector<size_t>(10,2), std::vector<size_t>(9,2));
40 | 	TTTensor B = TTTensor::random(std::vector<size_t>(10,2), std::vector<size_t>(9,2));
41 | 	
42 | 	
43 | 	Tensor Af(A);
44 | 	Tensor Bf(B);
45 | 	
46 | 	TTOperator Ao(Af);
47 | 	TTOperator Bo(Bf);
48 | 	
49 | 	TTTensor C = entrywise_product(A, B);
50 | 	TTOperator Co = entrywise_product(Ao, Bo);
51 | 	Tensor Cf = entrywise_product(Af, Bf);
52 | 	
53 | 	TEST(frob_norm(Cf - Tensor(Co))/frob_norm(Cf) < 1e-14);
54 | 	TEST(frob_norm(Cf - Tensor(C))/frob_norm(Cf) < 1e-14);
55 | });
56 | 
57 | 
58 | static misc::UnitTest tt_pseudo_inv("TT", "Non-operator Pseudo Inverse", [](){
59 | 	Index i,j,k,r1,r2,r3,r4;
60 | 	
61 | 	const size_t d = 2;
62 | 	
63 | 	const TTTensor op = TTTensor::random(std::vector<size_t>(2*d, 10), std::vector<size_t>(2*d-1, 4));
64 | 	
65 | 	TTTensor tmp = op;
66 | 	tmp.move_core(d);
67 | 	std::pair<TensorNetwork, TensorNetwork> parts = tmp.chop(d);
68 | 	Tensor core = tmp.get_component(d);
69 | 	Tensor U,S,V;
70 | 	(U(i,r1), S(r1,r2), V(r2,j^2)) = SVD(core(i,j^2));
71 | 	S.modify_diagonal_entries([](double &_v){
72 | 		if (_v>1e-10) {
73 | 			_v = 1/_v;
74 | 		}
75 | 	});
76 | 	TensorNetwork pInv;
77 | 	pInv(j, i^(d-1), k^d) = parts.first(k^d,r1) * U(r1,r2) * S(r2,r3) * V(r3,j,r4) * parts.second(r4,i^(d-1));
78 | 	
79 | 	double error = frob_norm(pInv(i^d,r1^d)*op(r1^d,r2^d)*pInv(r2^d,j^d) - pInv(i^d,j^d));
80 | 	MTEST(error < 1e-10, "A^+ A A^+ != A^+ ? " << error);
81 | 	
82 | 	error = frob_norm(op(i^d,r1^d)*pInv(r1^d,r2^d)*op(r2^d,j^d) - op(i^d,j^d));
83 | 	MTEST(error < 1e-10, "A A^+ A != A ? " << error);
84 | });
85 | 


--------------------------------------------------------------------------------
/src/unitTests/ttRounding.cxx:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | 
 21 | #include<xerus.h>
 22 | 
 23 | #include "../../include/xerus/test/test.h"
 24 | #include "../../include/xerus/misc/internal.h"
 25 | using namespace xerus;
 26 | 
 27 | static misc::UnitTest tt_round("TT", "TTTensor_Rounding", [](){
 28 |     Index i,j,k;
 29 |     
 30 |     Tensor A1 = Tensor::random({2});
 31 |     Tensor B1;
 32 |     TTTensor TTA1(A1, 1e-14);
 33 |     B1(i) = TTA1(i);
 34 |     TEST(approx_equal(B1,A1, 1e-14));
 35 |     
 36 |     TTA1.round(1e-14);
 37 |     B1(i) = TTA1(i);
 38 |     TEST(approx_equal(B1,A1, 1e-14));
 39 |     
 40 |     TTA1.round(1);
 41 |     B1(i) = TTA1(i);
 42 |     TEST(approx_equal(B1,A1, 1e-14));
 43 |     
 44 |     
 45 |     Tensor A2 = Tensor::random({2,2});
 46 |     Tensor B2;
 47 |     TTTensor TTA2(A2, 1e-14);
 48 |     B2(j,i) = TTA2(j,i);
 49 |     TEST(approx_equal(B2,A2, 1e-14));
 50 |     
 51 |     TTA2.round(1e-14);
 52 |     B2(j,i) = TTA2(j,i);
 53 |     TEST(approx_equal(B2,A2, 1e-14));
 54 |     
 55 |     TTA2.round(2);
 56 |     B2(j,i) = TTA2(j,i);
 57 |     TEST(approx_equal(B2,A2, 1e-14));
 58 |     
 59 |     
 60 |     Tensor A3 = Tensor::random({2,7});
 61 |     Tensor B3;
 62 |     TTTensor TTA3(A3, 1e-14);
 63 |     B3(j,i) = TTA3(j,i);
 64 |     TEST(approx_equal(B3,A3, 1e-14));
 65 |     
 66 |     TTA3.round(1e-14);
 67 |     B3(j,i) = TTA3(j,i);
 68 |     TEST(approx_equal(B3,A3, 1e-14));
 69 |     
 70 |     TTA3.round(2);
 71 |     B3(j,i) = TTA3(j,i);
 72 |     TEST(approx_equal(B3,A3, 1e-14));
 73 |     
 74 |     
 75 |     Tensor A4 = Tensor::random({2,2,2,2,2,2,2,2});
 76 |     Tensor B4;
 77 |     TTTensor TTA4(A4, 1e-14);
 78 |     B4(j,i^7) = TTA4(j,i^7);
 79 |     TEST(approx_equal(B4,A4, 1e-14));
 80 |     
 81 |     TTA4.round(1e-14);
 82 |     B4(j,i^7) = TTA4(j,i^7);
 83 |     TEST(approx_equal(B4,A4, 1e-14));
 84 |     
 85 |     TTA4.round(512);
 86 |     B4(j,i^7) = TTA4(j,i^7);
 87 |     TEST(approx_equal(B4,A4, 1e-14));
 88 |     
 89 |     
 90 |     Tensor A5 = Tensor::random({5,6,3,1,4,2,8,1});
 91 |     Tensor B5;
 92 |     TTTensor TTA5(A5, 1e-14);
 93 |     B5(j,i^7) = TTA5(j,i^7);
 94 |     TEST(approx_equal(B5,A5, 1e-14));
 95 |     
 96 |     TTA5.round(1e-14);
 97 |     B5(j,i^7) = TTA5(j,i^7);
 98 |     TEST(approx_equal(B5,A5, 1e-14));
 99 |     
100 |     TTA5.round(576);
101 |     B5(j,i^7) = TTA5(j,i^7);
102 |     TEST(approx_equal(B5,A5, 1e-14));
103 | });
104 | 
105 | 
106 | static misc::UnitTest tt_noround("TT", "no_rounding", [](){
107 |     Index i,j,k;
108 | 	TTTensor a = TTTensor::random({2,2,2,2,2,2,2}, {2,2,2,2,2,2});
109 | 	TTTensor b(a);
110 | 	a.round(2);
111 | 	TEST(approx_equal(Tensor(a),Tensor(b)));
112 | 	TTTensor c = TTTensor::random({2,2,2,2,2,2,2}, {2,2,2,2,2,2});
113 | 	a(i&0) = a(i&0) + 0.0*c(i&0);
114 | 	LOG(unit_test, a.ranks());
115 | 	a.round(2);
116 | 	TEST(approx_equal(Tensor(a), Tensor(b), 1e-14));
117 | });
118 | 


--------------------------------------------------------------------------------
/src/unitTests/tutorials.cxx:
--------------------------------------------------------------------------------
 1 | #include<xerus.h>
 2 | 
 3 | #include "../../include/xerus/test/test.h"
 4 | using namespace xerus;
 5 | 
 6 | static misc::UnitTest tut_quick("Tutorials", "quick_start", [](){
 7 | 	xerus::Tensor A({512,512}, [](const std::vector<size_t> &idx){
 8 | 		if (idx[0] == idx[1]) {
 9 | 			return 2.0;
10 | 		} else if (idx[1] == idx[0]+1 || idx[1]+1 == idx[0]) {
11 | 			return -1.0;
12 | 		} else {
13 | 			return 0.0;
14 | 		}
15 | 	});
16 | 	
17 | 	A *= 512*512;
18 | 	
19 | 	A.reinterpret_dimensions(std::vector<size_t>(18, 2));
20 | 	xerus::TTOperator ttA(A);
21 | 	
22 | // 	std::cout << "ttA ranks: " << ttA.ranks() << std::endl;
23 | 	
24 | 	xerus::Tensor b({512}, []() {
25 | 		return 1.0;
26 | 	});
27 | 	
28 | 	b.reinterpret_dimensions(std::vector<size_t>(9, 2));
29 | 	xerus::TTTensor ttb(b);
30 | 	
31 | 	xerus::TTTensor ttx = xerus::TTTensor::random(std::vector<size_t>(9, 2), std::vector<size_t>(8, 3));
32 | 	
33 | 	xerus::ALS_SPD(ttA, ttx, ttb);
34 | 	
35 | 	xerus::Index i,j,k;
36 | 	
37 | 	double residual = frob_norm( ttA(i^9,j^9)*ttx(j^9) - ttb(i^9) );
38 | 	MTEST(residual < 3.5e-9, residual);
39 | // 	std::cout << "residual: " << residual << std::endl;
40 | 	
41 | 	xerus::Tensor x;
42 | 	x(j^9) = b(i^9) / A(i^9, j^9);
43 | 	MTEST(frob_norm(x(i&0) - ttx(i&0)) < 3.5e-9, frob_norm(x(i&0) - ttx(i&0)));
44 | // 	std::cout << Tensor(ttx).to_string() << std::endl;
45 | // 	std::cout << "error: " << frob_norm(x(i&0) - ttx(i&0)) << std::endl;
46 | });
47 | 


--------------------------------------------------------------------------------
/src/unitTests/xPerformanceAnalysis.cxx:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | 
21 | #include<xerus.h>
22 | #include "../../include/xerus/misc/internal.h"
23 | 
24 | #include "../../include/xerus/test/test.h"
25 | using namespace xerus;
26 | 
27 | #ifdef XERUS_PERFORMANCE_ANALYSIS
28 | 	#ifdef XERUS_REPLACE_ALLOCATOR  
29 | 		static misc::UnitTest perfana("x_PerformanceAnalysis_x", "Analysis", [](){
30 | 			std::cout << misc::performanceAnalysis::get_analysis();
31 | 			LOG(Indices, "A total of " << Index().valueId << " indices were used (in this thread).");
32 | 			
33 | 			using xma = xerus::misc::AllocatorStorage;
34 | 			namespace xm = xerus::misc; 
35 | 			LOG(allocator, "");
36 | 			size_t totalStorage=0;
37 | 			for (size_t i=0; i<xma::NUM_BUCKETS; ++i) {
38 | 				if (xm::astore.allocCount[i] == 0 && xm::astore.currAlloc[i] == 0) continue;
39 | 				totalStorage += i * xma::BUCKET_SIZE * (size_t)xm::astore.maxAlloc[i];
40 | 				LOG(allocator, (i+1) * xma::BUCKET_SIZE-1 << " \tx\t " << xm::astore.allocCount[i] << "\tmax: " << xm::astore.maxAlloc[i] << '\t' << xm::astore.currAlloc[i] << '\t' << totalStorage);
41 | 			}
42 | 			LOG(storageNeeded, totalStorage << " storage used: " << misc::astore.pools.size()*xma::POOL_SIZE);
43 | 			LOG(index, sizeof(Index));
44 | 			LOG(node, sizeof(TensorNetwork::TensorNode));
45 | 			LOG(link, sizeof(TensorNetwork::Link));
46 | 			LOG(tn, sizeof(TensorNetwork));
47 | 			LOG(fulltensor, sizeof(Tensor));
48 | 			LOG(Tensor, sizeof(Tensor));
49 | 			LOG(tt, sizeof(TTTensor) << " | " << sizeof(TTOperator));
50 | 			LOG(measurement, sizeof(SinglePointMeasurment));
51 | 		});
52 | 	#else
53 | 		static misc::UnitTest perfana("x_PerformanceAnalysis_x", "Analysis", [](){
54 | 			std::cout << misc::performanceAnalysis::get_analysis();
55 | 			LOG(Indices, "A total of " << Index().valueId << " indices were used (in this thread).");
56 | 		});
57 | 	#endif
58 | #endif
59 | 


--------------------------------------------------------------------------------
/src/xerus/algorithms/decompositionAls.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the decomposition ALS.
23 |  */
24 | 
25 | #include <xerus/algorithms/decompositionAls.h>
26 | #include <xerus/basic.h>
27 | #include <xerus/index.h>
28 | #include <xerus/indexedTensorList.h>
29 | #include <xerus/tensorNetwork.h>
30 |  
31 | #include <xerus/indexedTensorMoveable.h>
32 | #include <xerus/indexedTensor_tensor_factorisations.h>
33 | 
34 | namespace xerus {
35 | 
36 | 	void decomposition_als(TTTensor& _x, const Tensor& _b, const double _eps, const size_t _maxIterations) {
37 | 		Index k, iU, iX, iL, rU, rL;
38 | 		Tensor newXi;
39 | 		
40 | 		double lastResidual = frob_norm(Tensor(_x) - _b);
41 | //         LOG(bla, "Initial residual " << lastResidual);
42 | 		
43 | 		for(size_t iteration = 0; iteration < _maxIterations; ++iteration) {
44 | 			// Move right
45 | 			for(size_t pos = 0; pos < _x.degree(); ++pos) { XERUS_REQUIRE_TEST;
46 | //                 LOG(bla, "Optimizing position " << pos);
47 | 				_x.move_core(pos);
48 | 				std::pair<TensorNetwork, TensorNetwork> split = _x.chop(pos);
49 | 				_x.component(pos)(rU, iX, rL) = split.first(iU&1, rU)*split.second(rL, iL&1)*_b(iU^pos, iX, iL&(pos+1));
50 | 			}
51 | 			
52 | 			// Move left
53 | 			for(size_t pos = _x.degree()-2; pos > 0; --pos) { XERUS_REQUIRE_TEST;
54 | //                 LOG(bla, "Optimizing position " << pos);
55 | 				_x.move_core(pos);
56 | 				std::pair<TensorNetwork, TensorNetwork> split = _x.chop(pos);
57 | 				_x.component(pos)(rU, iX, rL) = split.first(iU&1, rU)*split.second(rL, iL&1)*_b(iU^pos, iX, iL&(pos+1));
58 | 			}
59 | 			
60 | 			double residual = frob_norm(Tensor(_x) - _b);
61 | // 			LOG(bla, "New residual " << residual << ", residual change " << (lastResidual-residual)/residual);
62 | 			if(residual < EPSILON || (lastResidual-residual)/residual < _eps) { return; }
63 | 			lastResidual = residual;
64 | 		}
65 | 	}
66 | } // namespace xerus
67 | 


--------------------------------------------------------------------------------
/src/xerus/algorithms/largestEntry.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <xerus/algorithms/largestEntry.h>
 3 | 
 4 | namespace xerus {
 5 | 	template<bool isOperator>
 6 | 	size_t find_largest_entry(const TTNetwork<isOperator> &_T, const double _accuracy, const value_t _lowerBound) {
 7 | 		_T.require_correct_format();
 8 | 		
 9 | 		// There is actual work to be done
10 | 		if(misc::sum(_T.ranks()) >= _T.degree()) {
11 | 			const double alpha = _accuracy;
12 | 			
13 | 			TTNetwork<isOperator> X = _T;
14 | 			X.round(size_t(1));
15 | 			double Xn = std::max(_T[find_largest_entry(X, 0.0, 0.0)], _lowerBound);
16 | 			double tau = (1-alpha)*alpha*Xn*Xn/(2.0*double(_T.degree()-1));
17 | 			
18 | 			X = _T;
19 | 			while(misc::sum(X.ranks()) >= _T.degree()) {
20 | 				X = entrywise_product(X, X);
21 | 				
22 | 				X.soft_threshold(tau, true);
23 | 				
24 | 				TTNetwork<isOperator> Y = X;
25 | 				Y.round(1);
26 | 				const size_t yMaxPos = find_largest_entry(Y, 0.0, 0.0);
27 | 				
28 | 				Xn = std::max(X[yMaxPos], (1-(1-alpha)*alpha/2.0)*Xn*Xn);
29 | 				
30 | 				const double fNorm = X.frob_norm();
31 | 				Xn /= fNorm;
32 | 				X /= fNorm;
33 | 				tau = (1-alpha)*alpha*Xn*Xn/(2.0*double(_T.degree()-1));
34 | 			}
35 | 			return find_largest_entry(X, 0.0, 0.0);
36 | 		} 
37 | 		// We are already rank one
38 | 		const size_t numComponents = _T.degree()/(isOperator?2:1);
39 | 		size_t position = 0;
40 | 		size_t factor = misc::product(_T.dimensions);
41 | 		for(size_t c = 0; c < numComponents; ++c) {
42 | 			const size_t localSize = isOperator ? _T.dimensions[c]*_T.dimensions[numComponents+c] : _T.dimensions[c];
43 | 			factor /= localSize;
44 | 			
45 | 			size_t maxPos = 0;
46 | 			for(size_t i = 1; i < localSize; ++i) {
47 | 				if(std::abs(_T.get_component(c)[i]) > std::abs(_T.get_component(c)[maxPos])) {
48 | 					maxPos = i;
49 | 				}
50 | 			}
51 | 			position += maxPos*factor;
52 | 		}
53 | 		return position;
54 | 	}
55 | 	
56 | 	template size_t find_largest_entry(const TTNetwork<true> &, double, value_t);
57 | 	template size_t find_largest_entry(const TTNetwork<false> &, double, value_t);
58 | } // namespace xerus
59 | 


--------------------------------------------------------------------------------
/src/xerus/basic.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the array deleter classes.
23 |  */
24 | 
25 | #include <xerus/basic.h>
26 | 
27 | // Provide an implementation of the internal deleter functions
28 | namespace xerus {
29 | 	
30 |     namespace internal {
31 |         void array_deleter_vt(value_t* const _toDelete) { delete[] _toDelete; }
32 |         void array_deleter_st( size_t* const _toDelete) { delete[] _toDelete; }
33 |     } // namespace internal
34 | } // namespace xerus
35 | 


--------------------------------------------------------------------------------
/src/xerus/examples/specificLowRankTensors.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the examples of low-rank TT tensors defined in the respective header file.
23 |  */
24 | 
25 | #include <xerus/examples/specificLowRankTensors.h>
26 | #include <xerus/misc/internal.h>
27 | 
28 | namespace xerus { namespace examples {
29 | 	
30 | 	TTTensor peaking_diagonals(size_t _degree, size_t _n, value_t _alpha) {
31 | 		REQUIRE(_degree >= 2, "");
32 | 		REQUIRE(_n>=2, "");
33 | 		TTTensor e1(Tensor({_n}, [](){return 1.0;}));
34 | 		TTTensor cross(Tensor({_n,_n}, [&](const std::vector<size_t> &idx){
35 | 			return 1.0/(double(idx[0]>idx[1]?idx[0]-idx[1]:idx[1]-idx[0]) + _alpha) + 1.0/(double(idx[0])+_alpha) + 1.0/(double(idx[1])+_alpha);
36 | 		}));
37 | 		
38 | 		TTTensor result(cross);
39 | 		TTTensor buffer(e1);
40 | 		while (result.degree() < _degree) {
41 | 			result = dyadic_product(result, e1);
42 | 			TTTensor tmp = dyadic_product(buffer, cross);
43 | 			result += tmp;
44 | 			result.round(0.0);
45 | 			buffer = dyadic_product(buffer, e1);
46 | 		}
47 | 		return result;
48 | 	}
49 | 	
50 | } // namespace examples
51 | } // namespace xerus
52 | 
53 | 


--------------------------------------------------------------------------------
/src/xerus/examples/tensorCompletion.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the example measure sets for tensor completion.
23 |  */
24 | 
25 | #include <xerus/examples/tensorCompletion.h>
26 | #include <xerus/measurments.h>
27 | 
28 | namespace xerus { 
29 | 	namespace examples { 
30 | 		namespace completion {
31 | 	
32 | 			value_t inverse_index_norm(const std::vector<size_t>& _position, const value_t _additiveConst) {
33 | 				value_t normSqr = 0;
34 | 				for (const auto idx : _position) {
35 | 					normSqr += misc::sqr(static_cast<value_t>(idx) + _additiveConst);
36 | 				}
37 | 				return 1/std::sqrt(normSqr);
38 | 			}
39 | 			
40 | 			
41 | 			value_t inverse_index_ratio(const std::vector<size_t>& _position, const value_t _additiveConst) {
42 | 				value_t sum = 0;
43 | 				for (size_t j = 0; j+1 < _position.size(); ++j) {
44 | 					sum += (static_cast<value_t>(_position[j]) + 1.0) / (static_cast<value_t>(_position[j+1]) + _additiveConst);
45 | 				}
46 | 				return 1.0/(_additiveConst + sum);
47 | 			}
48 | 			
49 | 		} // namespace completion
50 | 	} // namespace examples
51 | } // namespace xerus
52 | 
53 | 


--------------------------------------------------------------------------------
/src/xerus/indexedTensor.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the IndexedTensor class.
23 |  */
24 | 
25 | #include <xerus/indexedTensor.h>
26 | 
27 | #include <xerus/index.h>
28 | #include <xerus/tensor.h>
29 | #include <xerus/tensorNetwork.h>
30 | #include <xerus/misc/internal.h>
31 | 
32 | namespace xerus {
33 | 	namespace internal {
34 | 		template<class tensor_type>
35 | 		IndexedTensor<tensor_type>::IndexedTensor(IndexedTensor &&_other ) : IndexedTensorWritable<tensor_type>(std::move(_other)) { }
36 | 
37 | 		template<class tensor_type>
38 | 		IndexedTensor<tensor_type>::IndexedTensor(tensor_type* const _tensorObject, const std::vector<Index>& _indices, const bool _takeOwnership) :
39 | 			IndexedTensorWritable<tensor_type>(_tensorObject, _indices, _takeOwnership) {}
40 | 			
41 | 		template<class tensor_type>
42 | 		IndexedTensor<tensor_type>::IndexedTensor(tensor_type* const _tensorObject, std::vector<Index>&& _indices, const bool _takeOwnership) :
43 | 			IndexedTensorWritable<tensor_type>(_tensorObject, std::move(_indices), _takeOwnership) {}
44 | 			
45 | 		
46 | 		
47 | 		template<class tensor_type>
48 | 		void IndexedTensor<tensor_type>::operator=(IndexedTensor<tensor_type>&& _rhs) {
49 | 			this->indexed_assignement(std::move(_rhs));
50 | 		}
51 | 		
52 | 		template<class tensor_type>
53 | 		void IndexedTensor<tensor_type>::operator=(IndexedTensorReadOnly<Tensor>&& _rhs) {
54 | 			this->indexed_assignement(std::move(_rhs));
55 | 		}
56 | 		
57 | 		template<class tensor_type>
58 | 		void IndexedTensor<tensor_type>::operator=(IndexedTensorReadOnly<TensorNetwork>&& _rhs) {
59 | 			this->indexed_assignement(std::move(_rhs));
60 | 		}
61 | 		
62 | 		template<class tensor_type>
63 | 		void IndexedTensor<tensor_type>::operator+=(IndexedTensorReadOnly<tensor_type>&& _rhs) {
64 | 			this->indexed_plus_equal(std::move(_rhs));
65 | 		}
66 | 		
67 | 		template<class tensor_type>
68 | 		void IndexedTensor<tensor_type>::operator-=(IndexedTensorReadOnly<tensor_type>&& _rhs) {
69 | 			this->indexed_minus_equal(std::move(_rhs));
70 | 		}
71 | 		
72 | 		// IndexedTensorReadOnly may be instanciated as
73 | 		template class IndexedTensor<Tensor>;
74 | 		template class IndexedTensor<TensorNetwork>;
75 | 	} // namespace internal
76 | } // namespace xerus
77 | 


--------------------------------------------------------------------------------
/src/xerus/indexedTensorList.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the IndexedTensorList.
23 |  */
24 | 
25 | #include <xerus/indexedTensorList.h>
26 | #include <xerus/indexedTensor_tensor_factorisations.h>
27 | 
28 | namespace xerus {
29 | 	namespace internal {
30 | 		IndexedTensorList::IndexedTensorList(IndexedTensorList&& _old) noexcept : tensors(std::move(_old.tensors)) { } 
31 | 		
32 | 		IndexedTensorList::IndexedTensorList(IndexedTensor<Tensor>&& _first, IndexedTensor<Tensor>&& _second) {
33 | 			tensors.emplace_back(&_first);
34 | 			tensors.emplace_back(&_second);
35 | 		}
36 | 		
37 | 		void IndexedTensorList::operator=(TensorFactorisation&& _factorisation) const {
38 | 			_factorisation(tensors);
39 | 		}
40 | 		
41 | 		/*- - - - - - - - - - - - - - - - - - - - - - - - - - External functions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
42 | 		
43 | 		IndexedTensorList operator,(IndexedTensor<Tensor>&& _first, IndexedTensor<Tensor>&& _second) {
44 | 			return IndexedTensorList(std::move(_first), std::move(_second));
45 | 		}
46 | 
47 | 		IndexedTensorList operator,(IndexedTensorList&& _first, IndexedTensor<Tensor>&& _second) {
48 | 			_first.tensors.emplace_back(&_second); // Hope this is standardconform. maybe we have to move-construct a new object
49 | 			return std::move(_first);
50 | 		}
51 | 	} // namespace internal
52 | } // namespace xerus
53 | 


--------------------------------------------------------------------------------
/src/xerus/indexedTensorMoveable.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the IndexedTensorMoveable class.
23 |  */
24 | 
25 | #include <xerus/indexedTensorMoveable.h>
26 | 
27 | #include <xerus/index.h>
28 | #include <xerus/tensor.h>
29 | #include <xerus/tensorNetwork.h>
30 | 
31 | namespace xerus {
32 | 	namespace internal {
33 | 		template<class tensor_type>
34 | 		IndexedTensorMoveable<tensor_type>::IndexedTensorMoveable() : IndexedTensorWritable<tensor_type>(nullptr, std::vector<Index>(), false) { }
35 | 		
36 | 		template<class tensor_type>
37 | 		IndexedTensorMoveable<tensor_type>::IndexedTensorMoveable(IndexedTensorMoveable<tensor_type> &&_other ) noexcept : IndexedTensorWritable<tensor_type>(std::move(_other)) { }
38 | 		
39 | 		template<class tensor_type>
40 | 		IndexedTensorMoveable<tensor_type>::IndexedTensorMoveable(tensor_type* const _tensorObject, const std::vector<Index>& _indices) : IndexedTensorWritable<tensor_type>(_tensorObject, _indices, true) {}
41 | 
42 | 		template<class tensor_type>
43 | 		IndexedTensorMoveable<tensor_type>::IndexedTensorMoveable(tensor_type* const _tensorObject, std::vector<Index>&& _indices) : IndexedTensorWritable<tensor_type>(_tensorObject, std::move(_indices), true) {}
44 | 		
45 | 		template<>
46 | 		IndexedTensorMoveable<TensorNetwork>::IndexedTensorMoveable(IndexedTensorReadOnly<TensorNetwork>&&  _other) :
47 | 			IndexedTensorWritable<TensorNetwork>(_other.tensorObjectReadOnly->get_copy(), std::move(_other.indices), true) { }
48 | 		
49 | 		template<>
50 | 		IndexedTensorMoveable<Tensor>::IndexedTensorMoveable(IndexedTensorReadOnly<Tensor>&&  _other) :
51 | 			IndexedTensorWritable<Tensor>(new Tensor(*_other.tensorObjectReadOnly), std::move(_other.indices), true) { }
52 | 		
53 | 		template<>template<>
54 | 		IndexedTensorMoveable<TensorNetwork>::IndexedTensorMoveable(IndexedTensorReadOnly<Tensor> && _other) : 
55 | 			IndexedTensorWritable<TensorNetwork>(new TensorNetwork(*_other.tensorObjectReadOnly), std::move(_other.indices), true) { }
56 | 
57 | 		template<>template<>
58 | 		IndexedTensorMoveable<Tensor>::IndexedTensorMoveable(IndexedTensorReadOnly<TensorNetwork> && _other ) : 
59 | 			IndexedTensorWritable<Tensor>(new Tensor(*_other.tensorObjectReadOnly), std::move(_other.indices), true) { }
60 | 		
61 | 		
62 | 		// IndexedTensorReadOnly may be instanciated as
63 | 		template class IndexedTensorMoveable<Tensor>;
64 | 		template class IndexedTensorMoveable<TensorNetwork>;
65 | 	} // namespace internal
66 | } // namespace xerus
67 | 


--------------------------------------------------------------------------------
/src/xerus/indexedTensor_tensor_solve.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 | * @file
22 | * @brief Implementation of the indexed tensor / operator.
23 | */
24 | 
25 | #include <xerus/misc/internal.h>
26 | #include <xerus/misc/containerSupport.h>
27 | 
28 | #include <xerus/index.h>
29 | #include <xerus/indexedTensor.h>
30 | #include <xerus/indexedTensorMoveable.h>
31 | #include <xerus/tensor.h>
32 | 
33 | namespace xerus {
34 | 	internal::IndexedTensorMoveable<Tensor> operator/ (internal::IndexedTensorReadOnly<Tensor>&& _b, internal::IndexedTensorReadOnly<Tensor>&& _A) {
35 | 		_A.assign_indices();
36 | 		_b.assign_indices();
37 | 		
38 | 		size_t extraDims = 0;
39 | 		std::vector<Index> orderA;
40 | 		std::vector<Index> orderB;
41 | 		std::vector<Index> orderX;
42 | 		
43 | 		// If possible we don't want to reorder A, so first divide A into those shared with b and x. 
44 | 		for(const Index& idx : _A.indices) {
45 | 			if(misc::contains(_b.indices, idx)) {
46 | 				orderA.push_back(idx);
47 | 			} else {
48 | 				orderX.push_back(idx);
49 | 			}
50 | 		}
51 | 		
52 | 		// This far the dimensions of A and B coincide
53 | 		orderB = orderA;
54 | 		
55 | 		// Add the second part of indices in the order obtained for X
56 | 		orderA.insert(orderA.end(), orderX.begin(), orderX.end());
57 | 		
58 | 		// Now complete indices of b and x with those not shared with A ( in order of b as we don't want to reorder b if possible).
59 | 		for(const Index& idx : _b.indices) {
60 | 			if(!misc::contains(_A.indices, idx)) {
61 | 				orderB.push_back(idx);
62 | 				orderX.push_back(idx);
63 | 				for(size_t i = 0; i < idx.span; ++i) {
64 | 					extraDims++;
65 | 				}
66 | 			}
67 | 		}
68 | 		
69 | 		// If indices coincide no reordering occours (only shared data pointer is set).
70 | 		Tensor reorderedA, reorderedB;
71 | 		reorderedA(orderA) = std::move(_A);
72 | 		reorderedB(orderB) = std::move(_b);
73 | 		
74 | 		internal::IndexedTensorMoveable<Tensor> tmpX(new Tensor(), std::move(orderX));
75 | 		
76 | 		//solve_least_squares(*tmpX.tensorObject, reorderedA, reorderedB, extraDims);
77 | 		solve(*tmpX.tensorObject, reorderedA, reorderedB, extraDims);
78 | 		
79 | 		return tmpX;
80 | 	}
81 | } // namespace xerus
82 | 


--------------------------------------------------------------------------------
/src/xerus/link.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the TensorNetwork::Link class.
23 |  */
24 | 
25 | #include <xerus/tensorNetwork.h>
26 | 
27 | namespace xerus {
28 | 	TensorNetwork::Link::Link(const size_t _other, const size_t _indexPos, const size_t _dim, const bool _external) noexcept 
29 | 		: other(_other), indexPosition(_indexPos), dimension(_dim), external(_external) {}
30 | 	
31 | 	bool TensorNetwork::Link::links(const size_t _other) const noexcept { return !external && other == _other; }
32 | 		
33 |     /*- - - - - - - - - - - - - - - - - - - - - - - - - - External functions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
34 |     
35 |     std::ostream &operator<<(std::ostream &_out, const xerus::TensorNetwork::Link &_rhs) {
36 |         _out << "L{";
37 | 		if (_rhs.external) {
38 | 			_out << "ext";
39 | 		} else {
40 | 			_out << _rhs.other;
41 | 		}
42 | 		_out << " (" << _rhs.indexPosition << "), dim " << _rhs.dimension << "}";
43 |         return _out;
44 |     }
45 | } // namespace xerus
46 | 


--------------------------------------------------------------------------------
/src/xerus/misc/exceptions.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the generic_error class.
23 |  */
24 | 
25 | #include <xerus/misc/exceptions.h>
26 | 
27 | namespace xerus {
28 |     namespace misc {
29 |         generic_error::generic_error() {}
30 |             
31 |         generic_error::generic_error(const generic_error &_other) noexcept
32 |             : error_info(_other.error_info) { }
33 |         
34 |         const char* generic_error::what() const noexcept {
35 |             return error_info.c_str();
36 |         }
37 |         
38 |     } // namespace misc
39 | } // namespace xerus
40 | 


--------------------------------------------------------------------------------
/src/xerus/misc/histogram.cpp:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | /**
 21 |  * @file
 22 |  * @brief Implementation of the histogram classes.
 23 |  */
 24 | 
 25 | #include <xerus/misc/histogram.h>
 26 | #include <xerus/misc.h>
 27 | #include <xerus/misc/internal.h>
 28 | 
 29 | namespace xerus { namespace misc {
 30 | 
 31 | 	LogHistogram::LogHistogram(const double _base) : base(_base), totalCount(0) {}
 32 | 	
 33 | 	LogHistogram &LogHistogram::operator+=(const LogHistogram &_other) {
 34 | 		REQUIRE(misc::approx_equal(_other.base, base), "only histograms of identical base can be added");
 35 | 		for (const auto &h : _other.buckets) {
 36 | 			buckets[h.first] += h.second;
 37 | 		}
 38 | 		totalCount += _other.totalCount;
 39 | 		return *this;
 40 | 	}
 41 | 	
 42 | 	void LogHistogram::add(double _value, size_t _count) {
 43 | 		double logRate = log(_value)/log(base);
 44 | 		REQUIRE(std::isfinite(_value), "tried to add illegal value " << _value << " into a histogram");
 45 | 		buckets[int(logRate)] += _count;
 46 | 		totalCount += _count;
 47 | 	}
 48 | 	
 49 | 	LogHistogram LogHistogram::read_from_file(const std::string &_fileName) {
 50 | 		std::ifstream in(_fileName);
 51 | 		LogHistogram result(0.0);
 52 | 		std::string line;
 53 | 		std::getline(in, line);
 54 | 		REQUIRE(line == "# raw data:", "unknown histogram file format " << _fileName); //TODO this should throw an exception
 55 | 		char c;
 56 | 		in >> c;
 57 | 		REQUIRE(c == '#', "missing information in histogram file " << _fileName);
 58 | 		in >> result.base >> result.totalCount;
 59 | 		std::getline(in, line); // read in rest of this line
 60 | 		std::getline(in, line); // line now contains all buckets
 61 | 		std::stringstream bucketData(line);
 62 | 		bucketData >> c;
 63 | 		REQUIRE(c == '#', "missing information in histogram file " << _fileName);
 64 | 		int bucketIndex;
 65 | 		while (bucketData >> bucketIndex) {
 66 | 			size_t count;
 67 | 			if (!(bucketData >> count)) {
 68 | 				LOG(fatal, "missing bucket count in histogram file " << _fileName);
 69 | 			}
 70 | 			result.buckets[bucketIndex] = count;
 71 | 		}
 72 | 		size_t accountedTime=0;
 73 | 		for (auto &h : result.buckets) {
 74 | 			accountedTime += h.second;
 75 | 		}
 76 | 		REQUIRE(accountedTime == result.totalCount, "histogram data inconsistent in file " << _fileName);
 77 | 		return result;
 78 | 	}
 79 | 	
 80 | 	void LogHistogram::dump_to_file(const std::string &_fileName) const {
 81 | 		std::ofstream out(_fileName);
 82 | 		out << "# raw data:\n";
 83 | 		out << "# " << base << ' ' << totalCount << '\n';
 84 | 		out << '#';
 85 | 		for (auto &h : buckets) {
 86 | 			out << ' ' << h.first << ' ' << h.second;
 87 | 		}
 88 | 		out << "\n# plotable data:\n";
 89 | 		if (!buckets.empty()) {
 90 | 			int firstOutput = buckets.begin()->first - 1;
 91 | 			int lastOutput = buckets.rbegin()->first + 1;
 92 | 			for (int i=firstOutput; i<=lastOutput; ++i) {
 93 | 				out << pow(base, i) << ' ';
 94 | 				if (buckets.count(i) > 0) {
 95 | 					out << double(buckets.find(i)->second)/double(totalCount) << '\n';
 96 | 				} else {
 97 | 					out << "0\n";
 98 | 				}
 99 | 			}
100 | 		}
101 | 		out.close();
102 | 	}
103 | 
104 | } // namespace misc
105 | } // namespace xerus
106 | 
107 | 


--------------------------------------------------------------------------------
/src/xerus/misc/missingFunctions.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the non-trivial non-template functions in the missingFunctions header.
23 |  */
24 | 
25 | #include <xerus/misc/missingFunctions.h>
26 | #include <xerus/misc/check.h>
27 | #include <xerus/misc/internal.h>
28 | 
29 | namespace xerus {
30 |     namespace misc {
31 | 		std::string exec(const std::string & _cmd) {
32 | 			FILE* pipe = popen(_cmd.c_str(), "r");
33 | 			REQUIRE(pipe, "could not start " << _cmd);
34 | 			char buffer[128];
35 | 			std::string result = "";
36 | 			while(feof(pipe) == 0) {
37 | 				if(fgets(buffer, 128, pipe) != nullptr) {
38 | 					result += buffer;
39 | 				}
40 | 			}
41 | 			pclose(pipe);
42 | 			return result;
43 | 		}
44 | 		
45 | 		void exec(const std::string & _cmd, const std::string &_stdin) {
46 | 			FILE* pipe = popen(_cmd.c_str(), "w");
47 | 			REQUIRE(pipe, "could not start " << _cmd);
48 | 			fputs(_stdin.c_str(), pipe);
49 | 			pclose(pipe);
50 | 		}
51 | 	} // namespace misc
52 | } // namespace xerus
53 | 


--------------------------------------------------------------------------------
/src/xerus/misc/random.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the non-template basic string functionality defined in stringUtilities.h.
23 |  */
24 | 
25 | #include <xerus/misc/random.h>
26 | 
27 | namespace xerus {
28 | 	namespace misc {
29 | 		thread_local std::mt19937_64 randomEngine(std::random_device{}());
30 | 		thread_local std::normal_distribution<double> defaultNormalDistribution;
31 | 	} // namespace misc
32 | } // namespace xerus
33 | 
34 | 


--------------------------------------------------------------------------------
/src/xerus/misc/standard.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief compilation unit for the version constants
23 |  */
24 | 
25 | #include <xerus/misc/standard.h>
26 | 
27 | namespace xerus {
28 | 	const int VERSION_MAJOR = XERUS_VERSION_MAJOR;
29 | 	const int VERSION_MINOR = XERUS_VERSION_MINOR;
30 | 	const int VERSION_REVISION = XERUS_VERSION_REVISION;
31 | 	const int VERSION_COMMIT = XERUS_VERSION_COMMIT;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/src/xerus/misc/stringUtilities.cpp:
--------------------------------------------------------------------------------
  1 | // Xerus - A General Purpose Tensor Library
  2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
  3 | // 
  4 | // Xerus is free software: you can redistribute it and/or modify
  5 | // it under the terms of the GNU Affero General Public License as published
  6 | // by the Free Software Foundation, either version 3 of the License,
  7 | // or (at your option) any later version.
  8 | // 
  9 | // Xerus is distributed in the hope that it will be useful,
 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 12 | // GNU Affero General Public License for more details.
 13 | // 
 14 | // You should have received a copy of the GNU Affero General Public License
 15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
 16 | //
 17 | // For further information on Xerus visit https://libXerus.org 
 18 | // or contact us at contact@libXerus.org.
 19 | 
 20 | /**
 21 |  * @file
 22 |  * @brief Implementation of the non-template basic string functionality defined in stringUtilities.h.
 23 |  */
 24 | 
 25 | #include <xerus/misc/stringUtilities.h>
 26 | #include <memory>
 27 | #include <sstream>
 28 | #include <cxxabi.h>
 29 | 
 30 | namespace xerus {
 31 | 	namespace misc {
 32 | 		
 33 | 		std::string demangle_cxa(const std::string &_cxa) {
 34 | 			int status;
 35 | 			std::unique_ptr<char, void(*)(void*)> realname(abi::__cxa_demangle(_cxa.data(), nullptr, nullptr, &status), &free);
 36 | 			if (status != 0) { return _cxa; }
 37 | 
 38 | 			if (realname) { 
 39 | 				return std::string(realname.get()); 
 40 | 			} 
 41 | 			return ""; 
 42 | 		}
 43 | 
 44 | 		std::string normalize_pathname(const std::string &_name) {
 45 | 			std::vector<std::string> oldpath = explode(_name,'/');
 46 | 			std::vector<std::string *> newpath;
 47 | 			for (std::string &f : oldpath) {
 48 | 				if (f.empty()) { continue; }
 49 | 				if (f==".." && !newpath.empty() && *newpath.back() != "..") {
 50 | 					newpath.pop_back();
 51 | 				} else {
 52 | 					newpath.push_back(&f);
 53 | 				}
 54 | 			}
 55 | 			std::string ret;
 56 | 			for (std::string *f : newpath) {
 57 | 				ret += *f;
 58 | 				ret += '/';
 59 | 			}
 60 | 			if (!ret.empty()) { ret.pop_back(); }
 61 | 			return ret;
 62 | 		}
 63 | 
 64 | 		std::vector<std::string> explode(const std::string& _string, const char _delim) {
 65 | 			std::vector<std::string> result;
 66 | 			std::istringstream iss(_string);
 67 | 
 68 | 			std::string token;
 69 | 			while(std::getline(iss, token, _delim)) {
 70 | 				result.push_back(std::move(token));
 71 | 			}
 72 | 
 73 | 			return result;
 74 | 		}
 75 | 
 76 | 		void replace(std::string& _string, const std::string& _search, const std::string& _replace) {
 77 | 			size_t pos = 0;
 78 | 			while((pos = _string.find(_search, pos)) != std::string::npos){
 79 | 				_string.replace(pos, _search.length(), _replace);
 80 | 				pos += _replace.length();
 81 | 			}
 82 | 		}
 83 | 		
 84 | 		std::string trim(const std::string& _string, const std::string& whitespace) {
 85 | 			const size_t strBegin = _string.find_first_not_of(whitespace);
 86 | 			if (strBegin == std::string::npos) {
 87 | 				return "";
 88 | 			} 
 89 | 			const size_t strEnd = _string.find_last_not_of(whitespace);
 90 | 			return _string.substr(strBegin, strEnd - strBegin + 1);
 91 | 		}
 92 | 
 93 | 		std::string reduce(const std::string& _string, const std::string& whitespace, const std::string& fill) {
 94 | 			// Trim first
 95 | 			auto trimedString = trim(_string, whitespace); 
 96 | 
 97 | 			// Replace sub ranges
 98 | 			auto beginSpace = trimedString.find_first_of(whitespace);
 99 | 			while (beginSpace != std::string::npos) {
100 | 				const auto endSpace = trimedString.find_first_not_of(whitespace, beginSpace);
101 | 				const auto range = endSpace - beginSpace;
102 | 
103 | 				trimedString.replace(beginSpace, range, fill);
104 | 
105 | 				const auto newStart = beginSpace + fill.length();
106 | 				beginSpace = trimedString.find_first_of(whitespace, newStart);
107 | 			}
108 | 			return trimedString;
109 | 		}
110 | 	} // namespace misc
111 | } // namespace xerus
112 | 


--------------------------------------------------------------------------------
/src/xerus/misc/timeMeasure.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the TimeMeasure class.
23 |  */
24 | 
25 | #include <xerus/misc/timeMeasure.h>
26 | #include <chrono>
27 | 
28 | namespace xerus {
29 |         namespace misc {
30 |         size_t uTime() {
31 |             return static_cast<size_t>(std::chrono::duration_cast<std::chrono::microseconds>
32 |                 (std::chrono::system_clock::now().time_since_epoch()).count());
33 |         }
34 | 
35 |         size_t mTime() {
36 |             return static_cast<size_t>(std::chrono::duration_cast<std::chrono::milliseconds>
37 |                 (std::chrono::system_clock::now().time_since_epoch()).count());
38 |         }
39 |     } // namespace misc
40 | } // namespace xerus
41 | 


--------------------------------------------------------------------------------
/src/xerus/python/factorizations.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Definition of the python bindings of tensor factorizations.
23 |  */
24 | 
25 | 
26 | #include "misc.h"
27 | 
28 | using namespace internal;
29 | 
30 | void expose_factorizations() {
31 | 	class_<TensorFactorisation, boost::noncopyable>("TensorFactorisation", boost::python::no_init)
32 | 		.def("__rlshift__", +[](TensorFactorisation &_rhs, object &_lhs){
33 | 			std::vector<IndexedTensor<Tensor>*> tmp = extract<std::vector<IndexedTensor<Tensor>*>>(_lhs);
34 | 			_rhs(tmp);
35 | 		})
36 | 	;
37 | 	class_<SVD, bases<TensorFactorisation>, boost::noncopyable>("SVD_temporary", boost::python::no_init);
38 | 	def("SVD", +[](IndexedTensor<Tensor> &_rhs, size_t _maxRank, double _eps)->TensorFactorisation*{
39 | 		return new SVD(std::move(_rhs), _maxRank, _eps);
40 | 	}, return_value_policy<manage_new_object,  // result is treated as a new object
41 | 			with_custodian_and_ward_postcall<0,1>>(), // but the argument will not be destroyed before the result is destroyed
42 | 		(arg("source"), arg("maxRank")=std::numeric_limits<size_t>::max(), arg("eps")=EPSILON)
43 | 	); 
44 | 	
45 | 	
46 | 	class_<QR, bases<TensorFactorisation>, boost::noncopyable>("QR_temporary", boost::python::no_init);
47 | 	def("QR", +[](IndexedTensor<Tensor> &_rhs)->TensorFactorisation*{
48 | 		return new QR(std::move(_rhs));
49 | 	}, return_value_policy<manage_new_object,  // result is treated as a new object
50 | 	   with_custodian_and_ward_postcall<0,1>>()); // but the argument will not be destroyed before the result is destroyed
51 | 	
52 | 	class_<RQ, bases<TensorFactorisation>, boost::noncopyable>("RQ_temporary", boost::python::no_init);
53 | 	def("RQ", +[](IndexedTensor<Tensor> &_rhs)->TensorFactorisation*{
54 | 		return new RQ(std::move(_rhs));
55 | 	}, return_value_policy<manage_new_object,  // result is treated as a new object
56 | 	   with_custodian_and_ward_postcall<0,1>>()); // but the argument will not be destroyed before the result is destroyed
57 | 	
58 | 	class_<QC, bases<TensorFactorisation>, boost::noncopyable>("QC_temporary", boost::python::no_init);
59 | 	def("QC", +[](IndexedTensor<Tensor> &_rhs)->TensorFactorisation*{
60 | 		return new QC(std::move(_rhs));
61 | 	}, return_value_policy<manage_new_object,  // result is treated as a new object
62 | 	   with_custodian_and_ward_postcall<0,1>>()); // but the argument will not be destroyed before the result is destroyed
63 | 	
64 | 	class_<CQ, bases<TensorFactorisation>, boost::noncopyable>("CQ_temporary", boost::python::no_init);
65 | 	def("CQ", +[](IndexedTensor<Tensor> &_rhs)->TensorFactorisation*{
66 | 		return new CQ(std::move(_rhs));
67 | 	}, return_value_policy<manage_new_object,  // result is treated as a new object
68 | 	   with_custodian_and_ward_postcall<0,1>>()); // but the argument will not be destroyed before the result is destroyed
69 | 	
70 | }
71 | 


--------------------------------------------------------------------------------
/src/xerus/python/misc.h:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Definition of common functions for the python bindings.
23 |  */
24 | 
25 | #include <boost/function.hpp>
26 | #include <boost/python.hpp>
27 | #include <boost/python/stl_iterator.hpp>
28 | #include <boost/python/call.hpp>
29 | #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
30 | #pragma GCC diagnostic push
31 | #pragma GCC diagnostic ignored "-Wuseless-cast"
32 | #pragma GCC diagnostic ignored "-Wold-style-cast"
33 | #pragma GCC diagnostic ignored "-Wcast-qual"
34 | #pragma GCC diagnostic ignored "-Wunused-function"
35 | #pragma GCC diagnostic ignored "-Wpedantic"
36 | #include <numpy/ndarrayobject.h>
37 | #pragma GCC diagnostic pop
38 | #include "xerus.h"
39 | #include "xerus/misc/internal.h"
40 | 
41 | using namespace boost::python;
42 | using namespace xerus;
43 | 
44 | 
45 | #define parametersDocstr "\n\nParameters\n----------\n"
46 | #define	returnsDocstr "\n\nReturns\n-------\n"
47 | 
48 | #define VECTOR_TO_PY(type, name) class_<std::vector<type>, boost::noncopyable>(name, no_init); \
49 | 	custom_vector_from_seq<type>(); \
50 | 	to_python_converter<std::vector<type>, custom_vector_to_list<type>>(); void(0)
51 | 
52 | #include "vectorAndPair.h"
53 | 
54 | void variable_argument_member_to_tuple_wrapper(const std::string &_name, const std::string &_tmpName = "new_fn");
55 | 
56 | void expose_tensor();
57 | void expose_factorizations();
58 | void expose_indexedTensors();
59 | void expose_tensorNetwork();
60 | void expose_ttnetwork();
61 | 
62 | void expose_leastSquaresAlgorithms();
63 | void expose_recoveryAlgorithms();
64 | 
65 | void expose_misc();
66 | 


--------------------------------------------------------------------------------
/src/xerus/python/python.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Definition of the python bindings.
23 |  */
24 | 
25 | #include "misc.h"
26 | 
27 | 
28 | // TODO get_copy() wrapper in python correct manner
29 | BOOST_PYTHON_MODULE(xerus) {
30 | 	using namespace xerus;
31 | 	
32 | 	import_array(); // for numpy
33 | 	
34 | 	bool show_user_defined = true;
35 | 	bool show_signatures = false;
36 | 	docstring_options doc_options(show_user_defined, show_signatures);
37 | 	
38 | 	// xerus version
39 | 	scope().attr("VERSION_MAJOR") = VERSION_MAJOR;
40 | 	scope().attr("VERSION_MINOR") = VERSION_MINOR;
41 | 	scope().attr("VERSION_REVISION") = VERSION_REVISION;
42 | 	scope().attr("VERSION_COMMIT") = VERSION_COMMIT;
43 | 	
44 | 	VECTOR_TO_PY(size_t, "IntegerVector");
45 | 	VECTOR_TO_PY(double, "DoubleVector");
46 | 	
47 | 	expose_indexedTensors();
48 | 	expose_factorizations();
49 | 	expose_tensor();
50 | 	expose_tensorNetwork();
51 | 	expose_ttnetwork();
52 | 	
53 | 	expose_leastSquaresAlgorithms();
54 | 	expose_recoveryAlgorithms();
55 | 	
56 | 	expose_misc();
57 | }
58 | 


--------------------------------------------------------------------------------
/src/xerus/python/vectorAndPair.h:
--------------------------------------------------------------------------------
 1 | 
 2 | template<typename containedType>
 3 | struct custom_vector_to_list{
 4 | 	static PyObject* convert(const std::vector<containedType>& v){
 5 | 		list ret;
 6 | 		for(const containedType& e : v) {
 7 | 			ret.append(e);
 8 | 		}
 9 | 		return incref(ret.ptr());
10 | 	}
11 | };
12 | template<typename containedType>
13 | struct custom_vector_from_seq{
14 | 	custom_vector_from_seq(){ converter::registry::push_back(&convertible,&construct,type_id<std::vector<containedType> >()); }
15 | 	static void* convertible(PyObject* obj_ptr){
16 | 		// the second condition is important, for some reason otherwise there were attempted conversions of Body to list which failed afterwards.
17 | 		if(!PySequence_Check(obj_ptr) || !PyObject_HasAttrString(obj_ptr,"__len__")) return 0;
18 | 		return obj_ptr;
19 | 	}
20 | 	static void construct(PyObject* obj_ptr, converter::rvalue_from_python_stage1_data* data){
21 | 		void* storage=(reinterpret_cast<converter::rvalue_from_python_storage<std::vector<containedType> >*>(data))->storage.bytes;
22 | 		new (storage) std::vector<containedType>();
23 | 		std::vector<containedType>* v=reinterpret_cast<std::vector<containedType>*>(storage);
24 | 		Py_ssize_t l=PySequence_Size(obj_ptr); if(l<0) abort();
25 | 		v->reserve(size_t(l)); 
26 | 		for (Py_ssize_t i=0; i<l; i++) { 
27 | 			v->push_back(extract<containedType>(PySequence_GetItem(obj_ptr,i))); 
28 | 		}
29 | 		data->convertible=storage;
30 | 	}
31 | };
32 | 
33 | /* Expose pairs */
34 | #pragma GCC diagnostic push
35 | #pragma GCC diagnostic ignored "-Wold-style-cast"
36 | 
37 | namespace py = boost::python;
38 | 
39 | template<typename T1, typename T2>
40 | struct PairToPythonConverter {
41 | 	static PyObject* convert(const std::pair<T1, T2>& pair)
42 | 	{
43 | 		return py::incref(py::make_tuple(pair.first, pair.second).ptr());
44 | 	}
45 | };
46 | 
47 | template<typename T1, typename T2>
48 | struct PythonToPairConverter {
49 | 	PythonToPairConverter()
50 | 	{
51 | 		py::converter::registry::push_back(&convertible, &construct, py::type_id<std::pair<T1, T2> >());
52 | 	}
53 | 	static void* convertible(PyObject* obj)
54 | 	{
55 | 		if (!PyTuple_CheckExact(obj)) return 0;
56 | 		if (PyTuple_Size(obj) != 2) return 0;
57 | 		return obj;
58 | 	}
59 | 	static void construct(PyObject* obj, py::converter::rvalue_from_python_stage1_data* data)
60 | 	{
61 | 		py::tuple tuple(py::borrowed(obj));
62 | 		void* storage = ((py::converter::rvalue_from_python_storage<std::pair<T1, T2> >*) data)->storage.bytes;
63 | 		new (storage) std::pair<T1, T2>(py::extract<T1>(tuple[0]), py::extract<T2>(tuple[1]));
64 | 		data->convertible = storage;
65 | 	}
66 | 	
67 | };
68 | 
69 | template<typename T1, typename T2>
70 | struct py_pair {
71 | 	py::to_python_converter<std::pair<T1, T2>, PairToPythonConverter<T1, T2> > toPy;
72 | 	PythonToPairConverter<T1, T2> fromPy;
73 | };
74 | 
75 | 
76 | #pragma GCC diagnostic pop
77 | /* End expose pair */
78 | 


--------------------------------------------------------------------------------
/src/xerus/tensorNode.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | /**
21 |  * @file
22 |  * @brief Implementation of the TensorNetwork::TensorNode class.
23 |  */
24 | 
25 | #include <xerus/tensorNetwork.h>
26 | #include <xerus/tensor.h>
27 | 
28 | namespace xerus {
29 |     
30 |     TensorNetwork::TensorNode::TensorNode() : erased(true) { }
31 |     
32 |     TensorNetwork::TensorNode::TensorNode(const TensorNetwork::TensorNode&  _other) : tensorObject(_other.tensorObject ? new Tensor(*_other.tensorObject) : nullptr), neighbors(_other.neighbors), erased(_other.erased) { }
33 |     
34 |     TensorNetwork::TensorNode::TensorNode(      std::unique_ptr<Tensor>&& _tensorObject) : tensorObject(std::move(_tensorObject)), neighbors(), erased(false) {}
35 |     
36 |     TensorNetwork::TensorNode::TensorNode(std::unique_ptr<Tensor>&& _tensorObject, std::vector<Link> _neighbors) : tensorObject(std::move(_tensorObject)), neighbors(std::move(_neighbors)), erased(false) {}
37 |     
38 |     TensorNetwork::TensorNode::~TensorNode() = default;
39 |     
40 |     TensorNetwork::TensorNode& TensorNetwork::TensorNode::operator=(const TensorNetwork::TensorNode&  _other) {
41 |         if(_other.tensorObject) {
42 | 			if(tensorObject) {
43 | 				*tensorObject = *_other.tensorObject;
44 | 			} else {
45 | 				tensorObject.reset( new Tensor(*_other.tensorObject));
46 | 			}
47 |         } else {
48 | 			tensorObject.reset();
49 | 		}
50 |         neighbors = _other.neighbors;
51 |         erased = _other.erased;
52 |         return *this;
53 |     }
54 |     
55 |     TensorNetwork::TensorNode& TensorNetwork::TensorNode::operator=( TensorNetwork::TensorNode&& _other) noexcept {
56 |         tensorObject = std::move(_other.tensorObject);
57 |         neighbors = std::move(_other.neighbors);
58 |         erased = _other.erased;
59 |         return *this;
60 |     }
61 |     
62 |     TensorNetwork::TensorNode TensorNetwork::TensorNode::strippped_copy() const {
63 |         return TensorNetwork::TensorNode(std::unique_ptr<Tensor>(), neighbors);
64 |     }
65 |         
66 |     size_t TensorNetwork::TensorNode::size() const noexcept {
67 |         size_t s = 1;
68 |         for (const Link &l : neighbors) {
69 |             s *= l.dimension;
70 |         }
71 |         return s;
72 |     }
73 |     
74 |     size_t TensorNetwork::TensorNode::degree() const noexcept {
75 |         return neighbors.size();
76 |     }
77 |     
78 |     void TensorNetwork::TensorNode::erase() noexcept {
79 |         erased = true;
80 |         neighbors.clear();
81 |         tensorObject.reset();
82 |     }
83 | } // namespace xerus
84 | 


--------------------------------------------------------------------------------
/src/xerus/tensor_specializations.cpp:
--------------------------------------------------------------------------------
 1 | // Xerus - A General Purpose Tensor Library
 2 | // Copyright (C) 2014-2017 Benjamin Huber and Sebastian Wolf. 
 3 | // 
 4 | // Xerus is free software: you can redistribute it and/or modify
 5 | // it under the terms of the GNU Affero General Public License as published
 6 | // by the Free Software Foundation, either version 3 of the License,
 7 | // or (at your option) any later version.
 8 | // 
 9 | // Xerus is distributed in the hope that it will be useful,
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 | // GNU Affero General Public License for more details.
13 | // 
14 | // You should have received a copy of the GNU Affero General Public License
15 | // along with Xerus. If not, see <http://www.gnu.org/licenses/>.
16 | //
17 | // For further information on Xerus visit https://libXerus.org 
18 | // or contact us at contact@libXerus.org.
19 | 
20 | #include <xerus/indexedTensorMoveable.h>
21 | #include <xerus/tensor.h>
22 | 
23 | namespace xerus {
24 |     /*
25 |     template<>template<>
26 |     IndexedTensorMoveable<Tensor>::IndexedTensorMoveable(const IndexedTensorReadOnly<Tensor> &  _other) : 
27 |         IndexedTensorWritable<Tensor>(_other.tensorObjectReadOnly->get_copy(), _other.indices, true) { }
28 |     
29 |     template<>template<>
30 |     IndexedTensorMoveable<Tensor>::IndexedTensorMoveable(      IndexedTensorReadOnly<Tensor> && _other) : 
31 |         IndexedTensorWritable<Tensor>(_other.tensorObjectReadOnly->get_copy(), std::move(_other.indices), true) { }*/
32 | } // namespace xerus


--------------------------------------------------------------------------------