Changeset 3795


Ignore:
Timestamp:
Feb 29, 2016 10:49:32 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 36daa4bde653baef804f51224f9ab4d25baaa523
end hash code: 4a9d2fa0ee12f868f0c5abd35f519fceb84c0a5e

commit 4a9d2fa0ee12f868f0c5abd35f519fceb84c0a5e
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 20:00:21 2016 -0700

jenkins.sh: remove flag that is no-longer present.
for_sparse_hes.cpp: fix vector size (boost vectors did not detect this).

commit b86c5a2e00c04336b88acdf32196c9004a686a65
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 17:23:38 2016 -0700

Add speed test option to use forward or reverse sparsity patterns.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/jenkins.sh

    r3788 r3795  
    119119        $build_type \\
    120120        --disable-silent-rules \\
    121         --with-implicit_ctor \\
    122121        ADOLC_DIR="$trunk_dir/build/prefix" \\
    123122        SACADO_DIR="$trunk_dir/build/prefix" \\
     
    129128if ! $trunk_dir/configure $build_type \
    130129        --disable-silent-rules \
    131         --with-implicit_ctor \
    132130        ADOLC_DIR="$trunk_dir/build/prefix" \
    133131        SACADO_DIR="$trunk_dir/build/prefix" \
  • trunk/speed/cppad/sparse_hessian.cpp

    r3794 r3795  
    6363                size_t m = f.Range();
    6464                CPPAD_ASSERT_UNKNOWN( m == 1 );
    65                 SetVector r_set(n);
    66                 for(size_t i = 0; i < n; i++)
    67                         r_set[i].insert(i);
    68                 f.ForSparseJac(n, r_set);
    6965                //
    7066                SetVector s_set(m);
    7167                s_set[0].insert(0);
    7268                //
    73                 sparsity_set = f.RevSparseHes(n, s_set);
     69                if( global_option["revsparsity"] )
     70                {       SetVector r_set(n);
     71                        for(size_t i = 0; i < n; i++)
     72                                r_set[i].insert(i);
     73                        f.ForSparseJac(n, r_set);
     74                        sparsity_set = f.RevSparseHes(n, s_set);
     75                }
     76                else
     77                {       SetVector r_set(1);
     78                        for(size_t i = 0; i < n; i++)
     79                                r_set[0].insert(i);
     80                        sparsity_set = f.ForSparseHes(r_set, s_set);
     81                }
    7482        }
    7583        void calc_sparsity(BoolVector& sparsity_bool, CppAD::ADFun<double>& f)
     
    7785                size_t m = f.Range();
    7886                CPPAD_ASSERT_UNKNOWN( m == 1 );
    79                 BoolVector r_bool(n * n);
    80                 size_t i, j;
    81                 for(i = 0; i < n; i++)
    82                 {       for(j = 0; j < n; j++)
    83                                 r_bool[ i * n + j] = false;
    84                         r_bool[ i * n + i] = true;
    85                 }
    86                 f.ForSparseJac(n, r_bool);
    8787                //
    8888                BoolVector s_bool(m);
    8989                s_bool[0] = true;
    9090                //
    91                 sparsity_bool = f.RevSparseHes(n, s_bool);
    92         }
    93 
     91                if( global_option["revsparsity"] )
     92                {       BoolVector r_bool(n * n);
     93                        for(size_t i = 0; i < n; i++)
     94                        {       for(size_t j = 0; j < n; j++)
     95                                        r_bool[ i * n + j] = i == j;
     96                        }
     97                        f.ForSparseJac(n, r_bool);
     98                        sparsity_bool = f.RevSparseHes(n, s_bool);
     99                }
     100                else
     101                {       BoolVector r_bool(n);
     102                        for(size_t i = 0; i < n; i++)
     103                                r_bool[i] = true;
     104                        sparsity_bool = f.ForSparseHes(r_bool, s_bool);
     105                }
     106        }
    94107}
    95108
  • trunk/speed/cppad/sparse_jacobian.cpp

    r3794 r3795  
    6161
    6262        void calc_sparsity(SetVector& sparsity_set, CppAD::ADFun<double>& f)
    63         {       size_t n = f.Domain();
    64                 SetVector r_set(n);
    65                 for(size_t j = 0; j < n; j++)
     63        {       bool reverse = global_option["revsparsity"];
     64                size_t q;
     65                if( reverse )
     66                        q = f.Range();
     67                else
     68                        q = f.Domain();
     69                //
     70                SetVector r_set(q);
     71                for(size_t j = 0; j < q; j++)
    6672                        r_set[j].insert(j);
    67                 sparsity_set = f.ForSparseJac(n, r_set);
     73                if( reverse )
     74                        sparsity_set = f.RevSparseJac(q, r_set);
     75                else
     76                        sparsity_set = f.ForSparseJac(q, r_set);
    6877        }
    6978        void calc_sparsity(BoolVector& sparsity_bool, CppAD::ADFun<double>& f)
    70         {       size_t n = f.Domain();
    71                 BoolVector r_bool(n * n);
    72                 size_t i, j;
    73                 for(i = 0; i < n; i++)
    74                 {       for(j = 0; j < n; j++)
    75                                 r_bool[ i * n + j] = false;
    76                         r_bool[ i * n + i] = true;
     79        {       bool reverse = global_option["revsparsity"];
     80                size_t q;
     81                if( reverse )
     82                        q = f.Range();
     83                else
     84                        q = f.Domain();
     85                //
     86                BoolVector r_bool(q * q);
     87                for(size_t i = 0; i < q; i++)
     88                {       for(size_t j = 0; j < q; j++)
     89                                r_bool[ i * q + j] = i == j;
    7790                }
    78                 sparsity_bool = f.ForSparseJac(n, r_bool);
     91                if( reverse )
     92                        sparsity_bool = f.RevSparseJac(q, r_bool);
     93                else
     94                        sparsity_bool = f.ForSparseJac(q, r_bool);
    7995        }
    8096
  • trunk/speed/main.cpp

    r3794 r3795  
    4949$begin speed_main$$
    5050$spell
     51        revsparsity
    5152        colpack
    5253        onetape
     
    234235$cref/vector of sets/glossary/Sparsity Pattern/Vector of Sets/$$.
    235236
     237$subhead revsparsity$$
     238If the option $code revsparsity$$ is present,
     239$codep
     240        global_option["revsparsity"]
     241$$
     242is true and otherwise it is false.
     243If it is true, CppAD will use a
     244$cref ForSparseJac$$ and $cref ForSparseHes$$ where possible
     245for its sparsity patterns.
     246Otherwise it will use $cref RevSparseJac$$ and $cref RevSparseHes$$.
     247
    236248$subhead colpack$$
    237249If the option $code colpack$$ is present,
     
    350362                "memory",
    351363                "boolsparsity",
     364                "revsparsity",
    352365                "colpack",
    353366        };
  • trunk/test_more/for_sparse_hes.cpp

    r3793 r3795  
    118118        // ------------------------------------------------------------------
    119119        // compute sparsity
    120         CPPAD_TESTVECTOR(bool) r(n), s(m), h(m * n);
     120        CPPAD_TESTVECTOR(bool) r(n), s(m), h(n * n);
    121121        for(j = 0; j < n; j++)
    122122                r[j] = true;
Note: See TracChangeset for help on using the changeset viewer.