int main() {
cout << plus<int>()(3,4) << endl; // prints 7
plus<int> intAdd; // function object that can add two int values
negate<int> intNegate; // function object that can negate an int value
// uses intAdd::operator(int, int) to add 10 and 20
int sum = intAdd(10, 20); // sum = 30
cout << sum << endl;
// uses intNegate::operator(int) to generate -10 as second parameter
// to intAdd::operator(int, int)
sum = intAdd(10, intNegate(10)); // sum = 0
cout << sum << endl;
int arry[] = {0,1,2,3,4,5,16,17,18,19};
vector<int> vec(arry, arry + 10);
cout <<
count_if(vec.begin(), vec.end(),
bind2nd(less_equal<int>(), 10));
cout << endl;
cout <<
count_if(vec.begin(), vec.end(),
not1(bind2nd(less_equal<int>(), 10)));
cout << endl;
return 0;
}
int main()
{
vector< int > v;
v.push_back(3);
v.push_back(5);
v.push_back(2);
cout << "min_odd = "
<< *min_element_if(v.begin(),
v.end(),
compose1_1(bind2nd(greater< int >(), 0),
bind2nd(modulus< int >(), 2)))
<< endl;
return 0;
}
PPMonoidElem SQFR(ConstRefPPMonoidElem T)
{
vector<long> expv;
exponents(expv,T);
replace_if(expv.begin(),expv.end(),bind2nd(not_equal_to<long>(),0),1);
return PPMonoidElem(owner(T),expv);
}//SQFR
BVHAccelTreeNode *BVHAccel::BuildHierarchy(vector<BVHAccelTreeNode *> &list, unsigned int begin, unsigned int end, unsigned int axis) {
const int treeType = 4; // Tree type to generate (2 = binary, 4 = quad, 8 = octree)
unsigned int splitAxis = axis;
float splitValue;
nNodes += 1;
if (end - begin == 1) // Only a single item in list so return it
return list[begin];
BVHAccelTreeNode *parent = new BVHAccelTreeNode();
parent->primitive = 0xffffffffu;
parent->leftChild = NULL;
parent->rightSibling = NULL;
vector<unsigned int> splits;
splits.reserve(treeType + 1);
splits.push_back(begin);
splits.push_back(end);
for (unsigned int i = 2; i <= treeType; i *= 2) { // Calculate splits, according to tree type and do partition
for (unsigned int j = 0, offset = 0; j + offset < i && splits.size() > j + 1; j += 2) {
if (splits[j + 1] - splits[j] < 2) {
j--;
offset++;
continue; // Less than two elements: no need to split
}
FindBestSplit(list, splits[j], splits[j + 1], &splitValue, &splitAxis);
vector<BVHAccelTreeNode *>::iterator it =
partition(list.begin() + splits[j], list.begin() + splits[j + 1], bind2nd(ptr_fun(bvh_ltf[splitAxis]), splitValue));
unsigned int middle = distance(list.begin(), it);
middle = max(splits[j] + 1, min(splits[j + 1] - 1, middle)); // Make sure coincidental BBs are still split
splits.insert(splits.begin() + j + 1, middle);
}
}
BVHAccelTreeNode *child, *lastChild;
// Left Child
child = BuildHierarchy(list, splits[0], splits[1], splitAxis);
parent->leftChild = child;
parent->bbox = child->bbox;
lastChild = child;
// Add remaining children
for (unsigned int i = 1; i < splits.size() - 1; i++) {
child = BuildHierarchy(list, splits[i], splits[i + 1], splitAxis);
lastChild->rightSibling = child;
parent->bbox = Union(parent->bbox, child->bbox);
lastChild = child;
}
return parent;
}
bool
Matrix::is_count_mat() const {
// TODO: this needs to be much more robust, or maybe we need to have
// a 3 way split: matrices can be freq or count, or just plain wrong
for (Matrix::const_iterator i = begin(); i != end(); ++i)
if (find_if(*i, *i + alphabet_size, bind2nd(greater<float>(), 1))
!= *i + alphabet_size)
return true;
return false;
}
Value * FunctionCallNode::GenerateCode (CodeGeneratorState & state) const {
Function * callee = state.module->getFunction (this->name.c_str ());
if (NULL == callee)
throw "Unknown function called";
if (callee->arg_size () != this->params->size ())
throw "Prototype mismatch";
vector <Value *> arguments;
arguments.reserve (this->params->size ());
transform (this->params->begin (), this->params->end (), back_inserter (arguments), bind2nd (mem_fun (& IASTNode::GenerateCode), state));
return state.builder->CreateCall (callee, arguments.begin (), arguments.end (), "tmp");
}
float StageClassifier::Evaluate(vector<vector<vector<float>>>& X, vector<bool>& y)
{
vector<float> probs;
vector<float> TPRs, FPRs;
float area = 0;
for (int i = 0; i < X.size(); i++)
probs.push_back(Predict(X[i]));
/* test on training set (0.5 threshhold??) */
//#if SETLEVEL == DEBUG_LEVEL
//int TP = 0, TN = 0;
//for (int i = 0; i < X.size(); i++)
//{
// if ((probs[i] >= 0.5) && y[i] == true)
// TP++;
// else if ((probs[i] < 0.5) && y[i] == false)
// TN++;
//}
//LOG_DEBUG_NN("\t\tStrong classifier: ");
//LOG_DEBUG_NN("TP = " << TP << '/' << y.size() / 2 << ", TN = " << TN << '/' << y.size() / 2);
//LOG_DEBUG_NN(", Result: " << (float)(TP + TN) / y.size());
//#endif
for (float threshhold = 1; threshhold >= 0; threshhold -= auc_step)
{
TPRs.push_back(count_if(probs.begin(), probs.begin() + n_pos, bind2nd(greater_equal<float>(), threshhold)) / (float)n_pos);
FPRs.push_back(count_if(probs.begin() + n_pos, probs.end(), bind2nd(greater_equal<float>(), threshhold)) / (float)n_neg);
if (FPRs.size() > 1)
area += (TPRs.back() + TPRs[TPRs.size() - 2]) * (FPRs.back() - FPRs[FPRs.size() - 2]) / 2; // trapezoid
//area += TPRs[TPRs.size() - 2] * (FPRs.back() - FPRs[FPRs.size() - 2]); // left riemann sum
//area += TPRs.back() * (FPRs.back() - FPRs[FPRs.size() - 2]); // right Riemann sum
}
return area;
}
void StageClassifier::SearchTheta(vector<vector<vector<float>>>& X, vector<bool>& y)
{
int whole_n_total = (int)y.size();
int whole_n_pos = (int)count(y.begin(), y.end(), true);
int whole_n_neg = (int)(whole_n_total - whole_n_pos);
vector<float> probs;
for (int i = 0; i < X.size(); i++)
probs.push_back(Predict(X[i]));
/* search min TPR */
float threshhold;
for (threshhold = 1; threshhold >= 0; threshhold -= search_step)
{
TPR = count_if(probs.begin(), probs.begin() + whole_n_pos, bind2nd(greater_equal<float>(), threshhold)) / (float)whole_n_pos;
if (TPR >= TPR_min)
break;
}
/* get corresponding theta and FPR */
theta = threshhold;
FPR = count_if(probs.begin() + whole_n_pos, probs.end(), bind2nd(greater_equal<float>(), threshhold)) / (float)whole_n_neg;
}
bool Coff_object::is_undef(const char a_sym[]) const
{
using std::find_if;
using std::not1;
using std::bind2nd;
using std::ptr_fun;
using std::strcmp;
typedef std::vector<const char*> T;
T::const_iterator beg_p = m_undef_symbols.begin();
T::const_iterator end_p = m_undef_symbols.end();
T::const_iterator pos = find_if( beg_p, end_p, not1(bind2nd( ptr_fun(strcmp), a_sym)) );
return (pos != end_p);
}
int main(int argc, char *argv[])
{
double duty = 0.5;
if (argc > 1)
{
duty = std::atof(argv[1]);
}
// sample frequency is fixed at 1 kHz, signal frequency at 10 Hz
Aquila::SquareGenerator gen(1000);
gen.setDuty(duty).setAmplitude(1).setFrequency(10).generate(1000);
// prints number of positive samples in generated signal
std::cout << count_if(gen.begin(), gen.end(),
bind2nd(greater<Aquila::SampleType>(), 0));
return 0;
}
Matrix
Matrix::combine(const Matrix &matrix1, const Matrix &matrix2, int offset) {
Matrix newmat;
newmat.width = std::max(matrix1.width,
matrix2.width + offset);
newmat.matrix = new float*[newmat.width];
for (size_t i = 0; i < newmat.width; ++i) {
newmat.matrix[i] = new float[alphabet_size];
fill(newmat.matrix[i], newmat.matrix[i] + alphabet_size, 0);
}
for (size_t i = 0; i < matrix1.width; ++i)
for (size_t j = 0; j < alphabet_size; ++j)
newmat.matrix[i][j] += matrix1.matrix[i][j];
for (size_t i = 0; i < matrix2.width; ++i)
for (size_t j = 0; j < alphabet_size; ++j)
newmat.matrix[i + offset][j] += matrix2.matrix[i][j];
for (size_t i = 0; i < newmat.width; ++i) {
const float total = accumulate(newmat.matrix[i],
newmat.matrix[i] + alphabet_size, 0.0);
transform(newmat.matrix[i], newmat.matrix[i] + alphabet_size,
newmat.matrix[i], bind2nd(divides<float>(), total));
}
return newmat;
}
void BBCutter::SetFillDutyCycle(float v) { for_each(procs.begin(),procs.end(),bind2nd(mem_fun(&CutProc::SetFillDutyCycle),v));}
void BBCutter::SetMaxPhraseLength(long v) { for_each(procs.begin(),procs.end(),bind2nd(mem_fun(&CutProc::SetMaxPhraseLength),v));}
DtxAck::DtxAck(const qpid::framing::SequenceSet& acked, DeliveryRecords& unacked)
{
remove_copy_if(unacked.begin(), unacked.end(), inserter(pending, pending.end()),
not1(bind2nd(mem_fun_ref(&DeliveryRecord::coveredBy), &acked)));
}
void BBCutter::SetMinPan(float v) { for_each(procs.begin(),procs.end(),bind2nd(mem_fun(&CutProc::SetMinPan),v));}
Value * ASTNodesListNode::GenerateCode (CodeGeneratorState & state) const {
for_each (this->exprs.begin (), this->exprs.end (), bind2nd (mem_fun (& IASTNode::GenerateCode), state));
}
void BBCutter::SetMaxDetune(float v) { for_each(procs.begin(),procs.end(),bind2nd(mem_fun(&CutProc::SetMaxDetune),v));}