Program Listing for File Paradigms.h

↰ Return to documentation for file (ADS/algorithm/Paradigms.h)

/*--------------------------------------------------------------------------*/
/*---------------------------- File Paradigms.h ----------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/

#ifndef __ADS_Paradigms
 #define __ADS_Paradigms
                      /* self-identification: #endif constant */

/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/Contract.h"

#include <optional>
#include <utility>
#include <vector>

/*--------------------------------------------------------------------------*/
/*--------------------------- NAMESPACE ------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace ADS {

template< class Z , class Next , class Last , class A , class O >
auto enumerateSearch( Z z , Next && next , Last && last , A && a , O && o )
 -> std::optional< decltype( o( z ) ) >;

template< class Z , class Next , class Last , class A , class O , class M ,
          class B >
auto enumerateOptimize( Z z , Next && next , Last && last , A && a ,
                        O && o , M && m , B && better )
 -> std::optional< decltype( o( z ) ) >;

template< class N , class C , class P , class L , class V >
bool backtrack( const N & node , C && children , P && prune , L && leaf ,
                V && visit );

template< class X , class Cand , class Best >
std::vector< X > greedy( int k , Cand && candidates , Best && best );

template< class X , class S , class D , class V , class C >
auto divideEtImpera( const X & x , S && small , D && direct , V && divide ,
                     C && combine ) -> decltype( direct( x ) );

template< class T , class B >
std::vector< T > maximal( const std::vector< T > & X , B && better );

/*--------------------------------------------------------------------------*/

}  // end( namespace ADS )

/*--------------------------------------------------------------------------*/
/*-------------------------- IMPLEMENTATION --------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/algorithm/impl/Paradigms.tpp"

/*--------------------------------------------------------------------------*/

#endif  /* Paradigms.h included */

/*--------------------------------------------------------------------------*/
/*-------------------------- End File Paradigms.h --------------------------*/
/*--------------------------------------------------------------------------*/