コード例 #1
0
int main(int argc, const char * argv[]) {
    // the integral of 1/sqrt(1-x^2) is arcsin(x)
    double exact = asin(0.99) - asin(0);
    double a = 0.0;
    double b = 0.99;
    std::vector<double> nodes;
    nodes.push_back(101);
    nodes.push_back(201);
    nodes.push_back(1001);
    nodes.push_back(2001);
    
    CompTrapRule ctp(&f, &fDoublePrime, a, b, nodes);
    std::vector<double> results = ctp.getResult();
    std::vector<double> hSteps = ctp.getHStep();
    std::vector<double> errorBounds = ctp.getErrorBound();
    
    std::cout << "Exact Value: " << exact << std::endl;
    for(unsigned i = 0; i < results.size(); i++){
        std::cout << "Composite Trapezoidal Rule approximation: " << std::setprecision(9)
            << results[i] << " with h step of " << hSteps[i] << ", an absolute erorr of "
            << absoluteError(exact, results[i]) << ", and error bound of "
            << errorBounds[i] << '.' << std::endl;
    }
    
    std::vector<double> extrp = extrapolation(results);
    for(unsigned i = 0; i < extrp.size(); i++){
        std::cout << "Richardson's Extrapolation approximation: " << std::setprecision(9)
        << extrp[i] << " with an absolute error of " << absoluteError(exact, extrp[i]) << std::endl;
    }
    return 0;
}
コード例 #2
-1
ファイル: AppUtilities.cpp プロジェクト: vxmdesign/gvxm
int AcontainsB(MapNode *pA, MapNode *pB){
  CheckTreeProc ctp(pB);
  int i;
  ProcTree(&ctp, pA);
  i = ctp.contains();
  return i;
}
コード例 #3
-1
ファイル: rewrites.cpp プロジェクト: configithub/numpy-gpu
thrust_rewriter::result_type thrust_rewriter::map_rewrite(
    const bind& n) {
    //The rhs must be an apply
    assert(detail::isinstance<apply>(n.rhs()));
    const apply& rhs = boost::get<const apply&>(n.rhs());
    //The rhs must apply a "map"
    assert(rhs.fn().id().substr(0, 3) == string("map"));
    const tuple& ap_args = rhs.args();
    //Map must have arguments
    assert(ap_args.begin() != ap_args.end());
    auto init = ap_args.begin();
    shared_ptr<const ctype::type_t> fn_t;

    if (detail::isinstance<apply>(*init)) {
        //Function instantiation
        const apply& fn_inst = boost::get<const apply&>(
            *init);
        if (detail::isinstance<templated_name>(fn_inst.fn())) {
            const templated_name& tn =
                boost::get<const templated_name&>(fn_inst.fn());
            const ctype::tuple_t& tt =
                tn.template_types();
            vector<shared_ptr<const ctype::type_t> > ttc;
            for(auto i = tt.begin();
                i != tt.end();
                i++) {
                ttc.push_back(i->ptr());
            }
            shared_ptr<const ctype::monotype_t> base =
                make_shared<const ctype::monotype_t>(tn.id());
            fn_t = make_shared<const ctype::polytype_t>(
                std::move(ttc), base);
        } else {
            assert(detail::isinstance<name>(fn_inst.fn()));
            string fn_id = fn_inst.fn().id();
            fn_t = make_shared<const ctype::monotype_t>(fn_id);
        }
    } else {
        //We must be dealing with a closure
        assert(detail::isinstance<closure>(*init));

        const closure& close = boost::get<const closure&>(
            *init);
        stringstream ss;
        ss << "closure";
        string closure_t_name = ss.str();
        shared_ptr<const ctype::monotype_t> closure_mt =
            make_shared<const ctype::monotype_t>(closure_t_name);
        vector<shared_ptr<const ctype::type_t> > cts;
        //By this point, the body of the closure is an
        //instantiated functor (which must be an apply node)
        assert(detail::isinstance<apply>(close.body()));
        const apply& inst_fctor =
            boost::get<const apply&>(close.body());
        stringstream os;
        //It's either a plain name or a templated name
        if (detail::isinstance<templated_name>(inst_fctor.fn())) {
            const templated_name& tn =
                boost::get<const templated_name&>(inst_fctor.fn());
            os << tn.id() << "<";
            const ctype::tuple_t& template_types =
                tn.template_types();
            ctype::ctype_printer ctp(m_target, os);
            for(auto i = template_types.begin();
                i != template_types.end();
                i++) {
                boost::apply_visitor(ctp, *i);
                if (std::next(i) != template_types.end()) {
                    os << ", ";
                }
            }
            os << " > ";
        } else {
            assert(detail::isinstance<name>(inst_fctor.fn()));
            const name& fnn =
                boost::get<const name&>(inst_fctor.fn());
            os << fnn.id();
        }
        cts.push_back(
            make_shared<const ctype::monotype_t>(
                os.str()));
        
        vector<shared_ptr<const ctype::type_t> > tuple_sub_cts;
        for(auto i = close.args().begin();
            i != close.args().end();
            i++) {
            //Can only close over names
            assert(detail::isinstance<name>(*i));
            const name& arg_i_name = boost::get<const name&>(*i);
            
            tuple_sub_cts.push_back(
                make_shared<const ctype::monotype_t>(
                    detail::typify(arg_i_name.id())));
        }
        cts.push_back(
            make_shared<const ctype::tuple_t>(
                std::move(tuple_sub_cts)));
        
        fn_t = make_shared<const ctype::polytype_t>(
            std::move(cts),
            closure_mt);
    }
    vector<shared_ptr<const ctype::type_t> > arg_types;
    for(auto i = init+1; i != ap_args.end(); i++) {
        //Assert we're looking at a name
        assert(detail::isinstance<name>(*i));
        arg_types.push_back(
            make_shared<const ctype::monotype_t>(
                detail::typify(boost::get<const name&>(*i).id())));
    }
    shared_ptr<const ctype::tuple_t> thrust_tupled =
        make_shared<const ctype::tuple_t>(
            std::move(arg_types));
    shared_ptr<const ctype::polytype_t> transform_t =
        make_shared<const ctype::polytype_t>(
            make_vector<shared_ptr<const ctype::type_t> >
            (fn_t)(thrust_tupled),
            make_shared<const ctype::monotype_t>("transformed_sequence"));
    shared_ptr<const apply> n_rhs =
        static_pointer_cast<const apply>(n.rhs().ptr());
    //Can only handle names on the LHS
    assert(detail::isinstance<name>(n.lhs()));
    const name& lhs = boost::get<const name&>(n.lhs());
    shared_ptr<const name> n_lhs = make_shared<const name>(lhs.id(),
                                                           lhs.type().ptr(),
                                                           transform_t);
    auto result = make_shared<const bind>(n_lhs, n_rhs);
    return result;
        
}