1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// Copyright (C) 2010 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#define DLIB_SYMMETRIC_MATRIX_CAcHE_ABSTRACT_H__
#ifndef DLIB_SYMMETRIC_MATRIX_CAcHE_ABSTRACT_H__
#include "matrix_abstract.h"
namespace dlib
{
// 
template <
typename cache_element_type
>
const matrix_exp symmetric_matrix_cache (
const matrix_exp& m,
long max_size_megabytes
);
/*!
requires
 m.size() > 0
 m.nr() == m.nc()
 max_size_megabytes >= 0
ensures
 This function assumes that m is symmetric. If m is not symmetric then it won't
crash but you will get incorrect results.
 This method creates a matrix expression which internally caches the elements
of m so that they can be accessed quickly. It is useful if m is some kind of
complex matrix expression which is both very large and expensive to evaluate.
An example would be a kernel_matrix() expression with an expensive kernel and
a large number of samples. Such an expression would result in a huge matrix,
potentially too big to store in memory. The symmetric_matrix_cache() then makes
it easy to store just the parts of a matrix expression which are accessed most
often in memory. The specific details are defined below.
 returns a matrix M such that
 M == m
(i.e. M represents the same matrix as m)
 M will cache elements of m and hold them internally so they can be quickly
accessed. In particular, M will attempt to allocate no more than
max_size_megabytes megabytes of memory for the purposes of caching
elements of m. When an element of the matrix is accessed it is either
retrieved from the cache, or if this is not possible, then an entire
column of m is loaded into a part of the cache which hasn't been used
recently and the needed element returned.
 diag(m) is always loaded into the cache and is stored separately from
the cached columns. That means accesses to the diagonal elements of m
are always fast.
 M will store the cached elements of m as cache_element_type objects.
Typically, cache_element_type will be float or double.
 To avoid repeated cache lookups, the following operations are optimized for
use with the symmetric_matrix_cache():
 diag(M), rowm(M,row_idx), colm(M,col_idx)
These methods will perform only one cache lookup operation for an
entire row/column/diagonal worth of data.
!*/
// 
}
#endif // DLIB_SYMMETRIC_MATRIX_CAcHE_ABSTRACT_H__
