SYMBOL INDEX (575 symbols across 97 files)

FILE: adept/Array.cpp
  type adept (line 13) | namespace adept {
    type internal (line 14) | namespace internal {
    function set_array_print_style (line 35) | void set_array_print_style(ArrayPrintStyle ps) {

FILE: adept/Minimizer.cpp
  type adept (line 16) | namespace adept {
    function to_lower_in_place (line 37) | static void to_lower_in_place(std::string& str) {
    function MinimizerStatus (line 118) | MinimizerStatus
    function MinimizerStatus (line 146) | MinimizerStatus

FILE: adept/Stack.cpp
  type adept (line 24) | namespace adept {
    function uIndex (line 195) | uIndex

FILE: adept/StackStorageOrig.cpp
  type adept (line 25) | namespace adept {
    type internal (line 26) | namespace internal {

FILE: adept/Storage.cpp
  type adept (line 13) | namespace adept {
    type internal (line 14) | namespace internal {

FILE: adept/cppblas.cpp
  type adept (line 61) | namespace adept {
    type internal (line 63) | namespace internal {
    type internal (line 188) | namespace internal {
  type adept (line 186) | namespace adept {
    type internal (line 63) | namespace internal {
    type internal (line 188) | namespace internal {

FILE: adept/cpplapack.h
  function namespace (line 48) | namespace adept {

FILE: adept/index.cpp
  type adept (line 12) | namespace adept {

FILE: adept/inv.cpp
  type adept (line 21) | namespace adept {
    function inv (line 29) | Array<2,Type,false>
    function inv (line 77) | SpecialMatrix<Type,SymmEngine<Orient>,false>
    function inv (line 132) | Array<2,Type,false>
    function inv (line 141) | SpecialMatrix<Type,SymmEngine<Orient>,false>
  type adept (line 124) | namespace adept {
    function inv (line 29) | Array<2,Type,false>
    function inv (line 77) | SpecialMatrix<Type,SymmEngine<Orient>,false>
    function inv (line 132) | Array<2,Type,false>
    function inv (line 141) | SpecialMatrix<Type,SymmEngine<Orient>,false>
  type adept (line 150) | namespace adept {
    function inv (line 29) | Array<2,Type,false>
    function inv (line 77) | SpecialMatrix<Type,SymmEngine<Orient>,false>
    function inv (line 132) | Array<2,Type,false>
    function inv (line 141) | SpecialMatrix<Type,SymmEngine<Orient>,false>

FILE: adept/jacobian.cpp
  type adept (line 18) | namespace adept {
    type internal (line 20) | namespace internal {
    function T (line 27) | T _check_long_double() {

FILE: adept/line_search.cpp
  type adept (line 15) | namespace adept {
    function MinimizerStatus (line 28) | MinimizerStatus
    function MinimizerStatus (line 89) | MinimizerStatus

FILE: adept/minimize_conjugate_gradient.cpp
  type adept (line 15) | namespace adept {
    function MinimizerStatus (line 22) | MinimizerStatus
    function MinimizerStatus (line 200) | MinimizerStatus

FILE: adept/minimize_levenberg_marquardt.cpp
  type adept (line 15) | namespace adept {
    function MinimizerStatus (line 20) | MinimizerStatus
    function MinimizerStatus (line 195) | MinimizerStatus

FILE: adept/minimize_limited_memory_bfgs.cpp
  type adept (line 15) | namespace adept {
    class LbfgsData (line 19) | class LbfgsData {
      method LbfgsData (line 22) | LbfgsData(int nx, int ni)
      method store (line 33) | void store(int iter, const Vector& x_diff, const Vector& gradient_di...
      method Vector (line 52) | Vector x_diff(int iter) {
      method Vector (line 55) | Vector gradient_diff(int iter) {
      method Real (line 59) | Real& alpha(int iter) { return alpha_[iter % ni_]; }
      method Real (line 60) | Real rho(int iter) const { return rho_[iter % ni_]; }
      method Real (line 61) | Real gamma(int iter) const { return gamma_[iter % ni_]; }
    function MinimizerStatus (line 80) | MinimizerStatus
    function MinimizerStatus (line 271) | MinimizerStatus

FILE: adept/settings.cpp
  type adept (line 25) | namespace adept {
    function version (line 32) | std::string
    function compiler_version (line 40) | std::string
    function compiler_flags (line 73) | std::string
    function configuration (line 85) | std::string
    function max_blas_threads (line 116) | int
    function set_max_blas_threads (line 133) | int
    function have_matrix_multiplication (line 146) | bool
    function have_linear_algebra (line 157) | bool

FILE: adept/solve.cpp
  type adept (line 26) | namespace adept {
    function solve (line 34) | Array<1,T,false>
    function solve (line 76) | Array<2,T,false>
    function solve (line 119) | Array<1,T,false>
    function solve (line 170) | Array<2,T,false>
    function solve (line 226) | Array<1,T,false>
    function solve (line 235) | Array<2,T,false>
    function solve (line 244) | Array<1,T,false>
    function solve (line 254) | Array<2,T,false>
  type adept (line 218) | namespace adept {
    function solve (line 34) | Array<1,T,false>
    function solve (line 76) | Array<2,T,false>
    function solve (line 119) | Array<1,T,false>
    function solve (line 170) | Array<2,T,false>
    function solve (line 226) | Array<1,T,false>
    function solve (line 235) | Array<2,T,false>
    function solve (line 244) | Array<1,T,false>
    function solve (line 254) | Array<2,T,false>

FILE: adept/vector_utilities.cpp
  type adept (line 13) | namespace adept {
    function linspace (line 15) | Array<1,Real,false>

FILE: benchmark/advection_schemes.h
  function aReal (line 64) | struct is_active<adept::aReal> { static const bool value = true; }
  type adept (line 71) | typedef adept::Array<1,Real,::is_active<aReal>::value> my_vector;
  type adept (line 93) | typedef adept::Array<1,Real,::is_active<aReal>::value> my_vector;

FILE: benchmark/animate.cpp
  function main (line 17) | int

FILE: benchmark/autodiff_benchmark.cpp
  function Real (line 22) | static
  function usage (line 36) | static
  function main (line 64) | int

FILE: benchmark/differentiator.h
  type TestAlgorithm (line 45) | enum TestAlgorithm {
  function std (line 59) | inline
  function class (line 72) | class differentiator_exception : public std::exception {
  function virtual (line 76) | virtual const char* what() const throw()
  function class (line 84) | class Differentiator {
  function virtual (line 118) | virtual bool adjoint(TestAlgorithm test_algorithm,
  function reset_timings (line 134) | void reset_timings() {
  function virtual (line 141) | virtual std::string name() const = 0; //{ return "GENERIC"; }
  function class (line 171) | class HandCodedDifferentiator
  function class (line 253) | class AdeptDifferentiator
  function virtual (line 285) | virtual bool adjoint(TestAlgorithm test_algorithm,
  function virtual (line 365) | virtual void no_openmp() {
  function virtual (line 369) | virtual void print() {
  function class (line 385) | class AdolcDifferentiator
  function class (line 521) | class CppadDifferentiator
  function class (line 639) | class SacadoDifferentiator
  type AutoDiffTool (line 737) | enum AutoDiffTool {
  function std (line 777) | inline
  function Differentiator (line 791) | inline

FILE: benchmark/math_benchmark.cpp
  function main (line 16) | int main(int argc, const char** argv)

FILE: benchmark/matrix_benchmark.cpp
  function time_matmul (line 8) | double
  function time_solve (line 50) | double
  function main (line 84) | int

FILE: include/Timer.h
  function class (line 28) | class Timer {
  function print (line 60) | void print() {
  function TimerInt (line 74) | TimerInt new_activity(const std::string& name) {
  function stop (line 82) | void stop() {
  function start (line 90) | void start(TimerInt activity) {
  function reset (line 111) | void reset(TimerInt activity) {
  function std (line 119) | const std::vector<double>& timings() { return timings_; }
  function timing (line 122) | double timing(TimerInt activity) {
  function TimerInt (line 132) | TimerInt size() {
  type timeval (line 154) | struct timeval

FILE: include/adept/Active.h
  type Type (line 59) | typedef Type T;
  function get_dimensions_ (line 475) | bool get_dimensions_(ExpressionSize<0>& dim) const { return true; }
  function is_aliased_ (line 483) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 487) | Type value_with_len_(const Index& j, const Index& len) const
  function get_values (line 584) | void get_values(const Active<Type>* a, Index n, Type* data)
  function get_gradients (line 607) | void get_gradients(const Active<Type>* a, Index n, Type* data)
  function namespace (line 633) | namespace internal {

FILE: include/adept/ActiveConstReference.h
  function namespace (line 25) | namespace adept {
  function Type (line 140) | Type get_gradient() const {
  function get_dimensions_ (line 243) | bool get_dimensions_(ExpressionSize<0>& dim) const { return true; }
  function is_aliased_ (line 251) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 255) | Type value_with_len_(const Index& j, const Index& len) const
  function namespace (line 343) | namespace internal {

FILE: include/adept/ActiveReference.h
  function namespace (line 25) | namespace adept {
  function namespace (line 476) | namespace internal {

FILE: include/adept/Allocator.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/Array.h
  function namespace (line 40) | namespace adept {
  function Array (line 1541) | Array
  function Index (line 1835) | Index dimension(int j) const {
  function Index (line 1838) | Index size(int j) const {
  function Index (line 1843) | Index offset(int j) const {
  function Type (line 1868) | Type* data() { return data_; }
  function Type (line 1869) | const Type* data() const { return data_; }
  function Type (line 1870) | const Type* const_data() const { return data_; }
  function Type (line 1873) | Type* data_pointer() { return data_; }
  function Type (line 1874) | const Type* data_pointer() const { return data_; }
  function Type (line 1875) | const Type* const_data_pointer() const { return data_; }
  function Type (line 1879) | Type* data_pointer(Index i) {
  function Type (line 1888) | const Type* const_data_pointer(Index i) const {
  function clear (line 1904) | void clear() {
  function resize (line 1959) | void resize(const ExpressionSize<Rank>& dim) {
  function resize_contiguous (line 1964) | void resize_contiguous(const ExpressionSize<Rank>& dim) {
  function resize_row_major (line 1969) | void resize_row_major(const ExpressionSize<Rank>& dim) {
  function resize_row_major_contiguous (line 1973) | void resize_row_major_contiguous(const ExpressionSize<Rank>& dim) {
  function resize_column_major (line 1977) | void resize_column_major(const ExpressionSize<Rank>& dim) {
  function Type (line 2104) | Type value_with_len_(const Index& j, const Index& len) const {

FILE: include/adept/ArrayWrapper.h
  function namespace (line 16) | namespace adept {
  type T (line 134) | typedef const T& __restrict type;

FILE: include/adept/BinaryOperation.h
  function namespace (line 17) | namespace adept {
  function is_aliased_ (line 115) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 144) | Type value_with_len_(const Index& j, const Index& len) const {
  function is_aliased_ (line 436) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 450) | Type value_with_len_(const Index& j, const Index& len) const {
  function is_aliased_ (line 634) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 648) | Type value_with_len_(const Index& j, const Index& len) const {
  function namespace (line 768) | namespace internal {
  type Subtract (line 817) | struct Subtract {
  type Multiply (line 860) | struct Multiply {
  type Divide (line 906) | struct Divide {
  type Pow (line 980) | struct Pow {
  type Atan2 (line 1039) | struct Atan2 {
  type Max (line 1099) | struct Max {
  type Min (line 1180) | struct Min {
  type CopySign (line 1260) | struct CopySign {
  type typename (line 1424) | typedef typename promote<typename
  type typename (line 1443) | typedef typename promote<typename

FILE: include/adept/Expression.h
  function namespace (line 22) | namespace adept {
  function namespace (line 268) | namespace internal {

FILE: include/adept/ExpressionSize.h
  function namespace (line 29) | namespace adept {
  function set_all (line 71) | void set_all(Index j) {
  function copy (line 78) | void copy(const ExpressionSize& d) {
  function copy (line 84) | void copy(const Index* d) {
  function Index (line 115) | Index size() const {
  function Index (line 168) | const Index& operator[](int i) const { return dim[i]; }
  function set_all (line 182) | void set_all(Index) const { }
  function const (line 185) | bool operator[](int) const { return 0; }
  function namespace (line 204) | namespace internal {
  function ExpressionSize (line 248) | inline ExpressionSize<1> expression_size(Index j0)
  function ExpressionSize (line 250) | inline ExpressionSize<2> expression_size(Index j0, Index j1)
  function ExpressionSize (line 254) | inline ExpressionSize<1> dimensions(Index j0)
  function ExpressionSize (line 256) | inline ExpressionSize<2> dimensions(Index j0, Index j1)
  function ExpressionSize (line 258) | inline ExpressionSize<3> dimensions(Index j0, Index j1, Index j2)
  function ExpressionSize (line 260) | inline ExpressionSize<4> dimensions(Index j0, Index j1, Index j2,
  function ExpressionSize (line 263) | inline ExpressionSize<5> dimensions(Index j0, Index j1, Index j2,
  function ExpressionSize (line 266) | inline ExpressionSize<6> dimensions(Index j0, Index j1, Index j2,
  function ExpressionSize (line 269) | inline ExpressionSize<7> dimensions(Index j0, Index j1, Index j2,

FILE: include/adept/FixedArray.h
  function namespace (line 27) | namespace adept {

FILE: include/adept/GradientIndex.h
  function namespace (line 8) | namespace adept {
  type GradientIndex (line 47) | struct GradientIndex
  function set (line 52) | void set(Index val) { }
  function clear (line 53) | void clear() { }

FILE: include/adept/IndexedArray.h
  function namespace (line 34) | namespace adept {
  function Index (line 157) | Index get_value_with_len(const std::vector<T>& ind, const Index& j,
  function get_dimensions_ (line 312) | bool get_dimensions_(ExpressionSize<Rank>& dim) const {
  function Type (line 370) | Type value_with_len_(const Index& i, const Index& len) const {
  function calc_gradient_ (line 424) | void calc_gradient_(Stack& stack,

FILE: include/adept/Minimizer.h
  function namespace (line 16) | namespace adept {
  function MinimizerAlgorithm (line 133) | MinimizerAlgorithm algorithm() { return algorithm_; }
  function max_iterations (line 135) | int max_iterations() { return max_iterations_; }
  function Real (line 136) | Real converged_gradient_norm() { return converged_gradient_norm_; }
  function set_max_line_search_iterations (line 147) | void set_max_line_search_iterations(int mi) { max_line_search_iterations...
  function set_armijo_coeff (line 148) | void set_armijo_coeff(Real ac)              {
  function set_lbfgs_curvature_coeff (line 156) | void set_lbfgs_curvature_coeff(Real lcc) {
  function set_cg_curvature_coeff (line 164) | void set_cg_curvature_coeff(Real cgcc) {
  function set_levenberg_damping_limits (line 313) | inline void
  function set_levenberg_damping_start (line 324) | inline void
  function set_levenberg_damping_restart (line 331) | inline void
  function set_levenberg_damping_multiplier (line 338) | inline void

FILE: include/adept/Optimizable.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/Packet.h
  function namespace (line 65) | namespace internal {
  type typename (line 116) | typedef typename quick_e::packet<T,size>::type intrinsic_type;
  function data (line 124) | Packet(const Packet& d) : PacketData<T>(d.data) { }
  function explicit (line 128) | explicit Packet(const T* d) : PacketData<T>(quick_e::load<intrinsic_type...
  function put (line 134) | void put(T* __restrict d) const { quick_e::store(d, data); }
  function put_unaligned (line 135) | void put_unaligned(T* __restrict d) const { quick_e::storeu(d, data); }
  function operator (line 141) | void operator+=(const Packet& d) { data = quick_e::add(data, d.data); }
  function operator (line 142) | void operator-=(const Packet& d) { data = quick_e::sub(data, d.data); }
  function operator (line 143) | void operator*=(const Packet& d) { data = quick_e::mul(data, d.data); }
  function operator (line 144) | void operator/=(const Packet& d) { data = quick_e::div(data, d.data); }
  function exp (line 280) | inline float  exp(float x)  { return quick_e::exp(x); }
  function exp (line 281) | inline double exp(double x) { return quick_e::exp(x); }
  function fastexp (line 283) | inline float  fastexp(float x)  { return quick_e::exp(x); }
  function fastexp (line 284) | inline double fastexp(double x) { return quick_e::exp(x); }
  function namespace (line 287) | namespace functions {

FILE: include/adept/RangeIndex.h
  function namespace (line 42) | namespace adept {
  function Index (line 195) | Index size_with_len_(const Index& len) const
  function get_dimensions_ (line 198) | bool get_dimensions_(ExpressionSize<1>& dim) const {
  function is_aliased_ (line 213) | bool is_aliased_(const Index* mem1, const Index* mem2) const {
  function Index (line 223) | Index value_with_len_(const Index&j, const Index& len) const
  function Index (line 247) | Index begin(Index len) const
  function Index (line 249) | Index end(Index len) const
  function Index (line 251) | Index stride(Index len) const
  function is_aliased_ (line 286) | bool is_aliased_(const Index* mem1, const Index* mem2) const { return fa...
  function Index (line 288) | Index size_with_len_(const Index& len) const
  function Index (line 291) | Index value_with_len_(const Index& j, const Index& len) const
  function Index (line 294) | Index value_at_location_(const ExpressionSize<1>& loc) const
  function Index (line 298) | Index end(Index len) const { return len-1; }
  function AllIndex (line 311) | struct is_range<AllIndex> {

FILE: include/adept/ScratchVector.h
  function namespace (line 32) | namespace adept {

FILE: include/adept/SpecialMatrix.h
  function namespace (line 31) | namespace adept {
  type SquareEngine (line 169) | struct SquareEngine
  function Index (line 173) | Index pack_offset(Index dim) const { return dim; }
  function Index (line 174) | Index index(Index i, Index j, Index offset) const {
  function get_row_range (line 181) | void get_row_range(Index i, Index dim, Index offset,
  function Index (line 215) | Index upper_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 218) | Index lower_offset(Index dim, Index offset, Index offdiag) const {
  type SquareEngine (line 221) | typedef SquareEngine<ROW_MAJOR> transpose_engine;
  type BandEngineHelper (line 242) | struct BandEngineHelper
  type BandEngineHelper (line 246) | struct BandEngineHelper
  type BandEngineHelper (line 250) | struct BandEngineHelper
  function Index (line 265) | Index pack_offset(Index dim) const { return diagonals-1; }
  function Index (line 266) | Index index(Index i, Index j, Index offset) const {
  function get_row_range (line 274) | void get_row_range(Index i, Index dim, Index offset,
  type BandEngine (line 282) | typedef BandEngine<COL_MAJOR,UDiags,LDiags> transpose_engine;
  function Index (line 336) | Index data_size(Index dim, Index offset) const {
  function Index (line 340) | Index upper_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 343) | Index lower_offset(Index dim, Index offset, Index offdiag) const {
  function check_upper_diag (line 346) | void check_upper_diag(Index offdiag) const {
  function check_lower_diag (line 352) | void check_lower_diag(Index offdiag) const {
  function Index (line 400) | Index index(Index i, Index j, Index offset) const {
  function get_row_range (line 408) | void get_row_range(Index i, Index dim, Index offset,
  type BandEngine (line 416) | typedef BandEngine<ROW_MAJOR,UDiags,LDiags> transpose_engine;
  function Index (line 472) | Index upper_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 476) | Index lower_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 511) | Index index(Index i, Index j, Index offset) const {
  function get_row_range (line 518) | void get_row_range(Index i, Index dim, Index offset,
  type SymmEngine (line 526) | typedef SymmEngine<ROW_LOWER_COL_UPPER> transpose_engine;
  function Index (line 557) | Index upper_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 560) | Index lower_offset(Index dim, Index offset, Index offdiag) const {
  type SymmEngine (line 579) | struct SymmEngine
  function Index (line 585) | Index pack_offset(Index dim) const { return dim; }
  function Index (line 586) | Index index(Index i, Index j, Index offset) const {
  function get_row_range (line 593) | void get_row_range(Index i, Index dim, Index offset,
  type SymmEngine (line 601) | typedef SymmEngine<ROW_UPPER_COL_LOWER> transpose_engine;
  function Index (line 602) | Index upper_offset(Index dim, Index offset, Index offdiag) const {
  function Index (line 605) | Index lower_offset(Index dim, Index offset, Index offdiag) const {
  function check_upper_diag (line 679) | void check_upper_diag(Index offdiag) const {
  type UpperEngine (line 758) | typedef UpperEngine<COL_MAJOR> transpose_engine;
  function get_row_range (line 759) | void get_row_range(Index i, Index dim, Index offset,
  type LowerEngine (line 771) | struct LowerEngine
  type UpperEngine (line 775) | typedef UpperEngine<ROW_MAJOR> transpose_engine;
  function get_row_range (line 776) | void get_row_range(Index i, Index dim, Index offset,
  function check_lower_diag (line 806) | void check_lower_diag(Index offdiag) const {
  function get_row_range (line 888) | void get_row_range(Index i, Index dim, Index offset,
  type UpperEngine (line 900) | struct UpperEngine
  type LowerEngine (line 901) | typedef LowerEngine<ROW_MAJOR> transpose_engine;
  function get_row_range (line 905) | void get_row_range(Index i, Index dim, Index offset,
  function storage_ (line 953) | SpecialMatrix(Index m0) : storage_(0) { resize(m0); }
  function SpecialMatrix (line 1328) | SpecialMatrix
  function SpecialMatrix (line 1352) | SpecialMatrix soft_link() {
  function get_dimensions_ (line 1424) | bool get_dimensions_(ExpressionSize<2>& dim) const {
  function Type (line 1469) | Type* data() { return data_; }
  function Type (line 1470) | const Type* data() const { return data_; }
  function Type (line 1471) | const Type* const_data() const { return data_; }
  function Type (line 1474) | Type* data_pointer() { return data_; }
  function Type (line 1475) | const Type* data_pointer() const { return data_; }
  function Type (line 1476) | const Type* const_data_pointer() const { return data_; }
  function clear (line 1484) | void clear() {
  function resize (line 1496) | void resize(Index dim) {
  function resize (line 1523) | void resize(Index dim0, Index dim1) {
  function is_aliased_ (line 1531) | bool is_aliased_(const Type* mem1, const Type* mem2) const {
  function Type (line 1546) | Type value_with_len_(const Index& j, const Index& len) const {
  function Index (line 1576) | Index gradient_index() const {
  function data_range (line 1641) | void data_range(Type const * &data_begin, Type const * &data_end) const {

FILE: include/adept/Stack.h
  function Type (line 72) | const Type& operator[](uIndex i) const { return data[i]; }
  function zero (line 74) | void zero() { for (uIndex i = 0; i < Size; i++) data[i] = 0.0; }
  type Gap (line 79) | struct Gap {
  type std (line 109) | typedef std::list<Gap>::iterator GapListIterator;
  function start (line 157) | void start(uIndex n = ADEPT_INITIAL_STACK_LENGTH) {
  function update_lhs (line 168) | bool update_lhs(const uIndex& gradient_index) {
  function uIndex (line 181) | uIndex register_gradient() {
  function uIndex (line 220) | uIndex register_gradients(const uIndex& n)  {
  function unregister_gradient (line 245) | void unregister_gradient(const uIndex& gradient_index) {
  function forward (line 362) | void forward() { return compute_tangent_linear(); }
  function reverse (line 368) | void reverse() { return compute_adjoint(); }
  function clear_gradients (line 495) | void clear_gradients() {
  function clear_independents (line 501) | void clear_independents() {
  function clear_dependents (line 507) | void clear_dependents() {
  function clear (line 512) | void clear() {
  function clear_statements (line 517) | void clear_statements() {
  function deactivate (line 531) | void deactivate() {
  function new_recording (line 544) | void new_recording() {
  function pause_recording (line 575) | bool pause_recording() {
  function continue_recording (line 586) | bool continue_recording() {
  function uIndex (line 692) | uIndex max_gradient_index() const {
  function Real (line 723) | Real fraction_multipliers_equal_to(Real val) {
  function preallocate_statements (line 742) | void preallocate_statements(uIndex n) {
  function preallocate_operations (line 747) | void preallocate_operations(uIndex n) {
  function preallocate_statements (line 845) | inline
  function preallocate_operations (line 849) | inline
  function Stack (line 855) | inline
  function is_thread_unsafe (line 862) | inline bool is_thread_unsafe() { return true; }
  function is_thread_unsafe (line 864) | inline bool is_thread_unsafe() { return false; }

FILE: include/adept/StackStorage.h
  function namespace (line 28) | namespace adept {

FILE: include/adept/StackStorageOrig.h
  function namespace (line 29) | namespace adept {

FILE: include/adept/StackStorageOrigStl.h
  function namespace (line 28) | namespace adept {

FILE: include/adept/Statement.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/Storage.h
  function namespace (line 42) | namespace internal {
  function remove_link (line 147) | void remove_link() {
  function Type (line 169) | Type*
  function Type (line 172) | const Type*
  function Index (line 215) | inline Index n_storage_objects()
  function Index (line 219) | inline Index n_storage_objects_created()
  function Index (line 222) | inline Index n_storage_objects_deleted()

FILE: include/adept/UnaryOperation.h
  function namespace (line 17) | namespace adept {
  function namespace (line 336) | namespace internal {

FILE: include/adept/array_shortcuts.h
  function namespace (line 17) | namespace adept {

FILE: include/adept/base.h
  function namespace (line 312) | namespace adept {

FILE: include/adept/contiguous_matrix.h
  function namespace (line 15) | namespace adept {

FILE: include/adept/cppblas.h
  function namespace (line 18) | namespace adept {

FILE: include/adept/eval.h
  function namespace (line 15) | namespace adept {

FILE: include/adept/exception.h
  function namespace (line 26) | namespace adept {
  function class (line 39) | class feature_not_available : public adept::exception {
  function class (line 51) | class autodiff_exception : public adept::exception { }
  function class (line 55) | class gradient_out_of_range : public autodiff_exception {
  function class (line 62) | class gradients_not_initialized : public autodiff_exception {
  function class (line 69) | class stack_already_active : public autodiff_exception {
  function class (line 76) | class dependents_or_independents_not_identified : public autodiff_except...
  function class (line 83) | class wrong_gradient : public autodiff_exception {
  function class (line 90) | class non_finite_gradient : public autodiff_exception {
  function class (line 103) | class array_exception : public adept::exception {
  function class (line 110) | class size_mismatch : public array_exception {
  function class (line 117) | class inner_dimension_mismatch : public array_exception {
  function class (line 124) | class empty_array : public array_exception {
  function class (line 131) | class invalid_dimension : public array_exception {
  function class (line 138) | class index_out_of_bounds : public array_exception {
  function class (line 145) | class invalid_operation : public array_exception {
  function class (line 152) | class matrix_ill_conditioned : public array_exception {
  function class (line 159) | class fortran_interoperability_error : public array_exception {
  function class (line 172) | class optimization_exception : public adept::exception {
  function namespace (line 191) | namespace internal {

FILE: include/adept/interp.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/inv.h
  function namespace (line 18) | namespace adept {

FILE: include/adept/matmul.h
  function namespace (line 19) | namespace adept {
  function namespace (line 617) | namespace internal {

FILE: include/adept/noalias.h
  function namespace (line 15) | namespace adept {

FILE: include/adept/outer_product.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/quick_e.h
  function namespace (line 111) | namespace quick_e {
  function V (line 204) | V set0() { return 0.0; }
  function fmin (line 218) | inline float  fmin(float x, float y)   { return std::fmin(x,y); }
  function fmin (line 219) | inline double fmin(double x, double y) { return std::fmin(x,y); }
  function fmax (line 220) | inline float  fmax(float x, float y)   { return std::fmax(x,y); }
  function fmax (line 221) | inline double fmax(double x, double y) { return std::fmax(x,y); }
  function select_gt (line 224) | inline float select_gt(float x1, float x2, float y1, float y2) {
  function select_gt (line 227) | inline double select_gt(double x1, double x2, double y1, double y2) {
  function all_in_range (line 231) | inline bool all_in_range(float x, float low_bound, float high_bound) {
  function all_in_range (line 234) | inline bool all_in_range(double x, double low_bound, double high_bound) {
  function __m128 (line 390) | inline __m128 unchecked_round(__m128 x)
  function __m128d (line 393) | inline __m128d unchecked_round(__m128d x)
  function __m128 (line 399) | inline __m128 unchecked_round(__m128 x)
  function __m128d (line 401) | inline __m128d unchecked_round(__m128d x)
  function unchecked_round (line 405) | inline float unchecked_round(float x)
  function unchecked_round (line 407) | inline double unchecked_round(double x)
  function pow2n (line 414) | inline float pow2n(float x)
  function pow2n (line 416) | inline double pow2n(double x)
  function horiz_and (line 420) | inline bool horiz_and(__m128i a) {
  function all_in_range (line 437) | inline bool all_in_range(__m128 x, float low_bound, float high_bound) {
  function all_in_range (line 442) | inline bool all_in_range(__m128d x, double low_bound, double high_bound) {
  function __m128 (line 449) | inline __m128 select_gt(__m128 x1, __m128 x2,
  function __m128d (line 459) | inline __m128d select_gt(__m128d x1, __m128d x2,
  function hsum (line 497) | inline float  hsum(__m256 x)  { return hsum(add(low(x), high(x))); }
  function hmul (line 498) | inline float  hmul(__m256 x)  { return hmul(mul(low(x), high(x))); }
  function hmin (line 499) | inline float  hmin(__m256 x)  { return hmin(fmin(low(x), high(x))); }
  function hmax (line 500) | inline float  hmax(__m256 x)  { return hmax(fmax(low(x), high(x))); }
  function hsum (line 501) | inline double hsum(__m256d x) { return hsum(add(low(x),  high(x))); }
  function hmul (line 502) | inline double hmul(__m256d x) { return hmul(mul(low(x),  high(x))); }
  function hmin (line 503) | inline double hmin(__m256d x) { return hmin(fmin(low(x), high(x))); }
  function hmax (line 504) | inline double hmax(__m256d x) { return hmax(fmax(low(x), high(x))); }
  function __m256 (line 515) | inline __m256 unchecked_round(__m256 x)
  function __m256d (line 518) | inline __m256d unchecked_round(__m256d x)
  function __m256 (line 529) | inline __m256 pow2n(__m256 n) {
  function __m256d (line 532) | inline __m256d pow2n(__m256d n) {
  function all_in_range (line 543) | inline bool all_in_range(__m256 x, float low_bound, float high_bound) {
  function all_in_range (line 549) | inline bool all_in_range(__m256d x, double low_bound, double high_bound) {
  function __m256 (line 555) | inline __m256 select_gt(__m256 x1, __m256 x2,
  function __m256d (line 559) | inline __m256d select_gt(__m256d x1, __m256d x2,
  function __m512 (line 590) | inline __m512 unchecked_round(__m512 x)   { return _mm512_roundscale_ps(...
  function __m512d (line 591) | inline __m512d unchecked_round(__m512d x) { return _mm512_roundscale_pd(...
  function all_in_range (line 601) | inline bool all_in_range(__m512 x, float low_bound, float high_bound) {
  function all_in_range (line 607) | inline bool all_in_range(__m512d x, double low_bound, double high_bound) {
  function __m512 (line 613) | inline __m512 select_gt(__m512 x1, __m512 x2,
  function __m512d (line 617) | inline __m512d select_gt(__m512d x1, __m512d x2,
  function float32x4_t (line 628) | inline float32x4_t vzeroq_f32() { return vdupq_n_f32(0.0); }
  function float64x2_t (line 629) | inline float64x2_t vzeroq_f64() { return vdupq_n_f64(0.0); }
  function vmulvq_f32 (line 631) | inline float vmulvq_f32(float32x4_t x) {
  function vmulvq_f64 (line 639) | inline double vmulvq_f64(float64x2_t x) {
  function all_in_range (line 668) | inline bool all_in_range(float32x4_t x, double low_bound, double high_bo...
  function all_in_range (line 678) | inline bool all_in_range(float64x2_t x, double low_bound, double high_bo...
  function float32x4_t (line 688) | inline float32x4_t unchecked_round(float32x4_t x) {
  function float64x2_t (line 691) | inline float64x2_t unchecked_round(float64x2_t x) {
  function float32x4_t (line 694) | inline float32x4_t select_gt(float32x4_t x1, float32x4_t x2,
  function float64x2_t (line 698) | inline float64x2_t select_gt(float64x2_t x1, float64x2_t x2,
  function unchecked_round (line 703) | inline float unchecked_round(float x)
  function unchecked_round (line 705) | inline double unchecked_round(double x)
  function pow2n (line 708) | inline float pow2n(float x) {
  function pow2n (line 711) | inline double pow2n(double x) {
  function Vec (line 725) | inline
  function Vec (line 736) | Vec fastexp_float(Vec const initial_x) {
  function Vec (line 812) | Vec fastexp_double(Vec const initial_x) {
  function __m128 (line 873) | inline __m128  exp(__m128 x)  { return fastexp_float(x);  }
  function __m128d (line 874) | inline __m128d exp(__m128d x) { return fastexp_double(x); }
  function __m256 (line 878) | inline __m256  exp(__m256 x)  { return fastexp_float(x);  }
  function __m256d (line 879) | inline __m256d exp(__m256d x) { return fastexp_double(x); }
  function __m512 (line 883) | inline __m512  exp(__m512 x)  { return fastexp_float(x);  }
  function __m512d (line 884) | inline __m512d exp(__m512d x) { return fastexp_double(x); }
  function float32x4_t (line 888) | inline float32x4_t exp(float32x4_t x) { return fastexp_float(x);  }
  function float64x2_t (line 889) | inline float64x2_t exp(float64x2_t x) { return fastexp_double(x); }
  function exp (line 894) | inline float  exp(float x)  { return quick_e::fastexp_float(x); }
  function exp (line 895) | inline double exp(double x) { return quick_e::fastexp_double(x); }
  function exp (line 899) | inline float  exp(float x)  { return std::exp(x); }
  function exp (line 900) | inline double exp(double x) { return std::exp(x); }

FILE: include/adept/reduce.h
  function namespace (line 47) | namespace adept {
  function namespace (line 100) | namespace internal {
  function finish_active (line 172) | void finish_active(Active<T>& total, const Index& n) {
  type T (line 181) | typedef T total_type;
  function T (line 186) | T first_value() { return 0; }
  type T (line 214) | typedef T total_type;
  function T (line 219) | T first_value() { return 1; }
  function finish_active (line 242) | void finish_active(Active<T>& total, const Index& n) { }
  type T (line 248) | typedef T total_type;
  function T (line 254) | T first_value() { return internal::numeric_limits<T>::min_inf(); }
  function accumulate (line 256) | void accumulate(T& total, const T& rhs) {
  function accumulate (line 266) | void accumulate(T& total, const T& rhs) {
  function accumulate (line 276) | void accumulate(Packet<T>& total, const Packet<T>& rhs) { total = fmax(t...
  function finish_active (line 299) | void finish_active(Active<T>& total, const Index& n) { }
  type T (line 305) | typedef T total_type;
  function T (line 310) | T first_value() { return internal::numeric_limits<T>::max_inf(); }
  function accumulate (line 312) | void accumulate(T& total, const T& rhs) {
  function accumulate_packet2 (line 316) | void accumulate_packet2(T& total, const Packet<T>& ptotal) {
  function accumulate (line 321) | void accumulate(T& total, const T& rhs) {
  function accumulate_packet2 (line 325) | void accumulate_packet2(T& total, const Packet<T>& ptotal) {
  function accumulate (line 330) | void accumulate(Packet<T>& total, const Packet<T>& rhs) { total = fmin(t...
  function finish_active (line 351) | void finish_active(Active<T>& total, const Index& n) { }
  type T (line 358) | typedef T total_type;
  function T (line 363) | T first_value() { return 0; }
  function finish_active (line 392) | void finish_active(Active<T>& total, const Index& n) {
  function first_value (line 408) | struct All {
  function accumulate (line 413) | void accumulate(bool& total, const bool& rhs)
  function first_value (line 422) | struct Any {
  function accumulate (line 427) | void accumulate(bool& total, const bool& rhs)
  function first_value (line 435) | struct Count {
  function accumulate (line 440) | void accumulate(Index& total, const bool& rhs)
  function reduce_dimension (line 607) | void reduce_dimension(const Expression<Type, E>& rhs, int reduce_dim,
  function reduce_active (line 714) | void reduce_active(const Expression<Type, E>& rhs, Active<Type>& total) {
  function reduce_dimension (line 772) | void reduce_dimension(const Expression<Type, E>& rhs, int reduce_dim,
  function Index (line 995) | Index count(const Expression<bool, E>& rhs)

FILE: include/adept/scalar_shortcuts.h
  function namespace (line 20) | namespace adept {
  function namespace (line 40) | namespace adept {

FILE: include/adept/settings.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/solve.h
  function namespace (line 18) | namespace adept {
  type typename (line 74) | typedef typename internal::promote<LType,RType>::type PType;
  type typename (line 90) | typedef typename internal::promote<LType,RType>::type PType;

FILE: include/adept/spread.h
  function namespace (line 15) | namespace adept {

FILE: include/adept/store_transpose.h
  function namespace (line 22) | namespace adept {

FILE: include/adept/traits.h
  function namespace (line 25) | namespace adept {
  type null_type (line 228) | struct null_type { }
  function null_type (line 233) | struct is_null_type<null_type>{
  type T (line 279) | typedef T type;
  type T (line 283) | typedef T type;
  type S (line 299) | typedef S type;
  type typename (line 302) | typedef typename S::type type;
  type typename (line 329) | typedef typename if_then_else<A_float_B_int, A, B>::type float_type;
  type typename (line 330) | typedef typename if_then_else<A_bigger_than_B, A, B>::type biggest_type;
  type typename (line 331) | typedef typename if_then_else<prefer_float, float_type, biggest_type>::t...
  type typename (line 334) | typedef typename promote_primitive<
  type typename (line 337) | typedef typename if_then_else<is_complex<L>::value
  type T (line 351) | typedef T type;
  type T (line 385) | typedef T type;
  type T (line 386) | typedef T type;
  type T (line 414) | typedef T type;
  type typename (line 420) | typedef typename initializer_list_rank<T>::type type;
  function float (line 434) | struct matrix_op_defined<float>  { static const bool value = true; }
  function double (line 437) | struct matrix_op_defined<double>  { static const bool value = true; }
  function float (line 447) | struct is_floating_point<float> { static const bool value = true; }
  function double (line 449) | struct is_floating_point<double> { static const bool value = true; }
  type is_floating_point (line 451) | struct is_floating_point

FILE: include/adept/vector_utilities.h
  function namespace (line 16) | namespace adept {

FILE: include/adept/where.h
  type no (line 60) | typedef struct { char array[2]; } no;

FILE: include/adept_fortran.h
  function namespace (line 87) | namespace adept {

FILE: test/algorithm.cpp
  function adouble (line 22) | adouble algorithm(const adouble x[2]) {

FILE: test/rosenbrock_banana_function.cpp
  function adouble (line 18) | adouble State::calc_function_value(const adouble* x) {

FILE: test/simulate_radiances.cpp
  function aReal (line 23) | static
  function simulate_radiances (line 51) | void

FILE: test/state.cpp
  function my_function_value (line 23) | double my_function_value(const gsl_vector* x, void* params) {
  function my_function_gradient (line 29) | void my_function_gradient(const gsl_vector* x, void* params, gsl_vector*...
  function my_function_value_and_gradient (line 35) | void my_function_value_and_gradient(const gsl_vector* x, void* params,

FILE: test/state.h
  function class (line 15) | class State {

FILE: test/test_adept.cpp
  function main (line 19) | int

FILE: test/test_adept_with_and_without_ad.cpp
  function main (line 27) | int

FILE: test/test_array_derivatives.cpp
  function algorithm (line 20) | void algorithm(const A& x, S& y) {
  function main (line 30) | int

FILE: test/test_array_speed.cpp
  function main (line 15) | int main()

FILE: test/test_arrays.cpp
  function main (line 41) | int

FILE: test/test_checkpoint.cpp
  function toon (line 27) | static
  function main (line 41) | int

FILE: test/test_constructors.cpp
  function Vector (line 23) | Vector square(const Vector& v) {
  function square_in_place (line 28) | void square_in_place(Vector& v) {
  function Vector (line 33) | Vector square_copy(Vector v) {
  function main (line 79) | int

FILE: test/test_derivatives.cpp
  function main (line 95) | int

FILE: test/test_fastexp.cpp
  function main (line 20) | int main(int argc, const char** argv)

FILE: test/test_fixed_arrays.cpp
  function main (line 26) | int

FILE: test/test_gsl_interface.cpp
  function main (line 21) | int

FILE: test/test_interp.cpp
  function main (line 29) | int

FILE: test/test_minimizer.cpp
  class RosenbrockN (line 22) | class RosenbrockN : public Optimizable {
    method RosenbrockN (line 25) | RosenbrockN() : ls_iteration_(0), exact_hessian_(false) {}
    method calc_y (line 40) | Array<1,Real,IsActive> calc_y(const Array<1,Real,IsActive>& x) {
    method calc_exact_hessian (line 51) | void calc_exact_hessian(const adept::Vector& x, SymmMatrix& hessian) {
    method report_progress (line 63) | virtual void report_progress(int niter, const adept::Vector& x,
    method state_to_stderr (line 70) | void state_to_stderr(const adept::Vector& x, Real cost) {
    method final_state_to_stderr (line 81) | void final_state_to_stderr(const adept::Vector& x, Real cost) {
    method provides_derivative (line 86) | virtual bool provides_derivative(int order) {
    method Real (line 95) | virtual Real calc_cost_function(const Vector& x) {
    method Real (line 103) | virtual Real calc_cost_function_gradient(const Vector& x,
    method Real (line 117) | virtual Real calc_cost_function_gradient_hessian(const Vector& x,
  function main (line 141) | int

FILE: test/test_misc.cpp
  function algorithm_ad (line 16) | double algorithm_ad(const double x_val[2], // Input values
  function main (line 32) | int main()

FILE: test/test_no_lib.cpp
  function algorithm_ad (line 24) | double algorithm_ad(const double x_val[2], // Input values
  function main (line 40) | int main()

FILE: test/test_packet_operations.cpp
  function p2v (line 21) | Array<1,Type> p2v(internal::Packet<Type> p) {
  function test_packet_operations (line 28) | void test_packet_operations() {
  function test_vector_operations (line 55) | void test_vector_operations(int N) {
  function test_unaligned_reduce (line 78) | void test_unaligned_reduce(int N) {
  function test_unaligned_assign (line 89) | void test_unaligned_assign(int N) {
  function main (line 106) | int

FILE: test/test_radiances.cpp
  function simulate_radiances_wrapper (line 19) | void simulate_radiances_wrapper(int n,
  function main (line 70) | int

FILE: test/test_radiances_array.cpp
  function simulate_radiances_wrapper (line 23) | void simulate_radiances_wrapper(int n,
  function main (line 78) | int

FILE: test/test_reduce_active.cpp
  function main (line 39) | int

FILE: test/test_thread_safe.cpp
  function toon (line 36) | static
  function compute (line 51) | static
  function main (line 133) | int

FILE: test/test_thread_safe_arrays.cpp
  function main (line 20) | int main(int argc, const char** argv)