自学教程：C++ to_vector函数代码示例

//根据先序和中序遍历结果构建树void bulid_by_preorder_inorder(){	int apreoder[] = { 1, 2, 4, 3, 5, 6};	int ainoder[] = { 4, 2, 1, 5, 3, 6};	int len = sizeof(apreoder)/sizeof(int);	vector<int> preoder = to_vector(apreoder,len);	vector<int> inoder = to_vector(ainoder,len);	treenode* root = bulid_by_preorder_inorder(preoder,inoder,0,len-1,0,len-1);	cout<<root->data<<endl;	levelorder(root);}				

void setup_vertex_normal_buffer_object(bool smoothed) {    std::vector<glm::vec3> vertices = trig.Vertices();    std::vector<glm::vec3> normals;    if (smoothed) {        // initialize map of normals to zero        // note that we store readily hashable vector<double> types instead of        // vec3s and convert between the two as required        // ...avoids some of the pain using <map> without much C++ knowledge        std::map< std::vector<double>, std::vector<double> > normal_map;        for (int i = 0; i < vertices.size(); i++) {            std::vector<double> zeros;            zeros.push_back(0.0);            zeros.push_back(0.0);            zeros.push_back(0.0);            normal_map[to_vector(vertices[i])] = zeros;        }        for (int i = 0; i < vertices.size(); i += 3) {            // get vertices of the current triangle            glm::vec3 v1 = vertices[i];            glm::vec3 v2 = vertices[i + 1];            glm::vec3 v3 = vertices[i + 2];            std::vector<double> v1_key = to_vector(v1);            std::vector<double> v2_key = to_vector(v2);            std::vector<double> v3_key = to_vector(v3);            // compute face normal            glm::vec3 face_normal = glm::cross(v3 - v2, v1 - v2);            // get the old vertex normal            glm::vec3 v1_old = to_vec3(normal_map[v1_key]);            glm::vec3 v2_old = to_vec3(normal_map[v2_key]);            glm::vec3 v3_old = to_vec3(normal_map[v3_key]);            // replace the old value with the new value            normal_map.erase(v1_key);            normal_map.erase(v2_key);            normal_map.erase(v3_key);            normal_map[v1_key] = to_vector(glm::normalize(v1_old + face_normal));            normal_map[v2_key] = to_vector(glm::normalize(v2_old + face_normal));            normal_map[v3_key] = to_vector(glm::normalize(v3_old + face_normal));        }        // convert the map of normals to a vector of normals        for (int i = 0; i < vertices.size(); i++) {            normals.push_back(to_vec3(normal_map[to_vector(vertices[i])]));        }    } else {        for (int i = 0; i < vertices.size(); i += 3) {            // get vertices of this triangle            glm::vec3 v1 = vertices[i];            glm::vec3 v2 = vertices[i + 1];            glm::vec3 v3 = vertices[i + 2];            // compute face normal            glm::vec3 face_normal = glm::cross(v3 - v2, v1 - v2);            normals.push_back(glm::normalize(face_normal));            normals.push_back(glm::normalize(face_normal));            normals.push_back(glm::normalize(face_normal));        }    }    glGenBuffers(1, &vertex_normal_buffer);    glBindBuffer(GL_ARRAY_BUFFER, vertex_normal_buffer);    glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * normals.size(),                 &normals[0], GL_STATIC_DRAW);}

 /** Setup fixture */ corrected_intensity_write_read_fixture_v3() {     typedef metric_type::uint_t uint_t;     typedef metric_type::ushort_t ushort_t;     uint_t calledCounts1[] = {52, 1049523, 654071, 500476, 982989};     ushort_t correctedIntCalled1[] = {245, 252, 61, 235};     expected_metrics.push_back(metric_type(7, 1114, 1, to_vector(correctedIntCalled1), to_vector(calledCounts1)));     uint_t calledCounts2[] = {0, 1063708, 582243, 588028, 953132};     ushort_t correctedIntCalled2[] = {232, 257, 68, 228};     expected_metrics.push_back(metric_type(7, 1114, 2, to_vector(correctedIntCalled2), to_vector(calledCounts2)));     uint_t calledCounts3[] = {0, 1022928, 617523, 594836, 951825};     ushort_t correctedIntCalled3[] = {227, 268, 68, 229};     expected_metrics.push_back(metric_type(7, 1114, 3, to_vector(correctedIntCalled3), to_vector(calledCounts3)));     setup_write_read(); }

	CUGIP_DECL_DEVICE	TElement &	get(coord_t aCoords)	{		TElement *buffer = reinterpret_cast<TElement *>(data);		return buffer[get_linear_access_index(to_vector(TStaticSize()), aCoords)];	}

void rtlr::initialize(multilayer_perceptron* mlp){    assert(mlp);    _mlp = mlp;    _netValueDerivates = _mlp->_netValueDerivates.get_arrays() | to_vector();    _pValuesPool = _mlp->context()->device_array_management()->create_pool(false);    _uLayersCount = _mlp->_layers.size() - 1;    _maxULayerSize = _mlp->_layers |    where([](row_numbered<layer_ptr>& l) { return l.row_num() != 0; }) |    max_value([](row_numbered<layer_ptr>& l) { return l.value()->size(); });        for (idx_t lidx = 1; lidx < _mlp->_layers.size(); lidx++)    {        _inputLayerInfos.emplace_back();        _pValues.emplace_back();        auto& layer = _mlp->_layers[lidx].value();        _pValues.back().emplace_back(create_p_values_for_weights(_mlp->_biases.get(lidx)));        for (auto& inputLayer : layer->input_layers())        {            idx_t iidx = _mlp->get_layer_index(inputLayer);            _inputLayerInfos.back().emplace_back();            auto& info = _inputLayerInfos.back().back();            info.index = iidx - 1;            info.size = inputLayer->size();            info.weights = _mlp->_weights.get(make_pair(iidx, lidx));            info.is_element_of_u = inputLayer != _mlp->_layers[0].value();            _pValues.back().emplace_back(create_p_values_for_weights(info.weights));        }    }    _pValuesPool->allocate();}

 std::vector<std::string> peer_groups() const {     zlist_t* peerGroups = zyre_peer_groups(m_self);     std::vector<std::string> ret;     if(peerGroups == NULL) {         return ret;     }     ret = to_vector(peerGroups);     zlist_destroy(&peerGroups);     return ret; }

 std::vector<std::string> own_groups() const {     zlist_t* ownGroups = zyre_own_groups(m_self);     std::vector<std::string> ret;     if(ownGroups == NULL) {         return ret;     }     ret = to_vector(ownGroups);     zlist_destroy(&ownGroups);     return ret; }

void test_movable() {    MyMovableRange range{3};    auto transformed = sl::ranges::transform(std::move(range), [](my_movable el) {        return el.get_val();    });    auto vec = transformed.to_vector();    slassert(3 == vec.size());    slassert(1 == vec[0]);    slassert(2 == vec[1]);    slassert(3 == vec[2]);}

void BackupSystem::generate_keypair(const std::wstring &recipient, const std::wstring &filename, const std::string &symmetric_key){	while (1){		CryptoPP::RSA::PrivateKey rsaPrivate;		rsaPrivate.GenerateRandomWithKeySize(*random_number_generator, 4 << 10);		if (!rsaPrivate.Validate(*random_number_generator, 3))			continue;		CryptoPP::RSA::PublicKey rsaPublic(rsaPrivate);		if (!rsaPublic.Validate(*random_number_generator, 3))			continue;		auto pri = to_vector(rsaPrivate);		auto pub = to_vector(rsaPublic);		RsaKeyPair pair(pri, pub, symmetric_key);		boost::filesystem::ofstream file(filename, std::ios::binary);		SerializerStream ss(file);		ss.begin_serialization(pair, false);		break;	}}

static Vec3d* this_vector(lua_State* l){    CelxLua celx(l);    Vec3d* v3 = to_vector(l, 1);    if (v3 == NULL)    {        celx.doError("Bad vector object!");    }        return v3;}

unsigned int GameInstSet::hash() const {	unsigned int hash = 0xbabdabe;	std::vector<GameInst*> as_vector = to_vector();	for (int i = 0; i < as_vector.size(); i++) {		GameInst* inst = as_vector[i];		if (!dynamic_cast<AnimatedInst*>(inst)) {			hash ^= inst->integrity_hash();			hash ^= hash * 31337; //Ad hoc hashing yay		}	}	return hash;}

    /** Setup fixture */    corrected_intensity_hardcoded_fixture_v2()    {        typedef metric_type::uint_t uint_t;        typedef metric_type::ushort_t ushort_t;        ushort_t correctedIntAll1[] = {1213, 966, 960, 1095};        ushort_t correctedIntCalled1[] = {4070, 4074, 4029, 3972};        uint_t calledCounts1[] = {0, 698433, 548189, 548712, 646638};        expected_metrics.push_back(                metric_type(1, 1104, 25, 1063, 11.9458876f, to_vector(correctedIntCalled1), to_vector(correctedIntAll1),                            to_vector(calledCounts1)));        ushort_t correctedIntAll2[] = {1558, 1151, 1158, 1293};        uint_t calledCounts2[] = {10938, 733661, 537957, 543912, 615504};        ushort_t correctedIntCalled2[] = {5013, 4983, 4915, 4932};        expected_metrics.push_back(                metric_type(1, 1104, 1, 1295, 13.3051805f, to_vector(correctedIntCalled2), to_vector(correctedIntAll2),                            to_vector(calledCounts2)));        ushort_t correctedIntAll3[] = {1171, 932, 912, 1069};        uint_t calledCounts3[] = {0, 706987, 556441, 556067, 653959};        ushort_t correctedIntCalled3[] = {3931, 3931, 3923, 3878};        expected_metrics.push_back(                metric_type(1, 1105, 25, 1025, 11.7396259f, to_vector(correctedIntCalled3), to_vector(correctedIntAll3),                            to_vector(calledCounts3)));        int tmp[] = {2, 48, 1, 0, 80, 4, 25, 0, 39, 4, 189, 4, 198, 3, 192, 3, 71, 4, 230, 15, 234, 15, 189, 15, 132,                     15, 0, 0, 0, 0, 65, 168, 10, 0, 93, 93, 8, 0, 104, 95, 8, 0, 238, 221, 9, 0, 91, 34, 63, 65, 1, 0,                     80, 4, 1, 0, 15, 5, 22, 6, 127, 4, 134, 4, 13, 5, 149, 19, 119, 19, 51, 19, 68, 19, 186, 42, 0, 0,                     221, 49, 11, 0, 101, 53, 8, 0, 168, 76, 8, 0, 80, 100, 9, 0, 5, 226, 84, 65, 1, 0, 81, 4, 25, 0, 1,                     4, 147, 4, 164, 3, 144, 3, 45, 4, 91, 15, 91, 15, 83, 15, 38, 15, 0, 0, 0, 0, 171, 201, 10, 0, 153,                     125, 8, 0, 35, 124, 8, 0, 135, 250, 9, 0, 130, 213, 59, 65        };        setup_hardcoded_binary(tmp, header_type());    }

SkVector SkEvalQuadTangentAt(const SkPoint src[3], SkScalar t) {    SkASSERT(src);    SkASSERT(t >= 0 && t <= SK_Scalar1);    Sk2s P0 = from_point(src[0]);    Sk2s P1 = from_point(src[1]);    Sk2s P2 = from_point(src[2]);    Sk2s B = P1 - P0;    Sk2s A = P2 - P1 - B;    Sk2s T = A * Sk2s(t) + B;    return to_vector(T + T);}

	CUGIP_DECL_DEVICE	void load(TView aView, coord_t aCorner/*region<cDimension> aRegion*/)	{		int index = threadOrderFromIndex();		TElement *buffer = reinterpret_cast<TElement *>(data);		while (index < cElementCount) {			auto coords = min_coords(				aView.dimensions()-coord_t(1, FillFlag()),				max_coords(coord_t(),					aCorner + index_from_linear_access_index(to_vector(TStaticSize()), index)));			buffer[index] = aView[coords];			index += TThreadBlockSize::count();		}	}

void test_const_ref() {    std::vector<my_movable> vec{};    vec.emplace_back(my_movable(41));    vec.emplace_back(my_movable(42));    vec.emplace_back(my_movable(43));        const std::vector<my_movable> vec2 = std::move(vec);    const std::vector<my_movable>& vec2ref = vec2;        int sum = 0;    auto transformed1 = sl::ranges::transform(sl::ranges::refwrap(vec2ref), [&sum](const my_movable& el) {        sum += el.get_val();        return std::ref(el);    });    auto filtered = sl::ranges::filter(std::move(transformed1), [](const my_movable&) {        return false;    }, sl::ranges::ignore_offcast<const my_movable&>);    auto res = filtered.to_vector();}

SkVector SkEvalQuadTangentAt(const SkPoint src[3], SkScalar t) {    // The derivative equation is 2(b - a +(a - 2b +c)t). This returns a    // zero tangent vector when t is 0 or 1, and the control point is equal    // to the end point. In this case, use the quad end points to compute the tangent.    if ((t == 0 && src[0] == src[1]) || (t == 1 && src[1] == src[2])) {        return src[2] - src[0];    }    SkASSERT(src);    SkASSERT(t >= 0 && t <= SK_Scalar1);    Sk2s P0 = from_point(src[0]);    Sk2s P1 = from_point(src[1]);    Sk2s P2 = from_point(src[2]);    Sk2s B = P1 - P0;    Sk2s A = P2 - P1 - B;    Sk2s T = A * Sk2s(t) + B;    return to_vector(T + T);}

void test_transform_refwrapped() {    std::vector<my_movable> vec{};    vec.emplace_back(my_movable(41));    vec.emplace_back(my_movable(42));    vec.emplace_back(my_movable(43));        std::list<my_movable> li{};    li.emplace_back(91);    li.emplace_back(92);    auto transformed = sl::ranges::transform(sl::ranges::refwrap(vec), [](my_movable& el) {        el.set_val(el.get_val() + 10);        return std::ref(el);    });    auto filtered = sl::ranges::filter(std::move(transformed), [](my_movable& el) {        return 52 != el.get_val();    }, sl::ranges::ignore_offcast<my_movable&>);    auto transformed2 = sl::ranges::transform(std::move(filtered), [](my_movable& el) {        el.set_val(el.get_val() - 10);        return std::ref(el);    });    auto refwrapped2 = sl::ranges::refwrap(li);    auto concatted = sl::ranges::concat(std::move(transformed2), std::move(refwrapped2));    //auto res will work too    std::vector<std::reference_wrapper<my_movable>> res = concatted.to_vector();    slassert(4 == res.size());    slassert(41 == res[0].get().get_val());    slassert(43 == res[1].get().get_val());    slassert(91 == res[2].get().get_val());    slassert(92 == res[3].get().get_val());    slassert(3 == vec.size());    slassert(41 == vec[0].get_val());    slassert(52 == vec[1].get_val());    slassert(43 == vec[2].get_val());    slassert(2 == li.size());    slassert(91 == li.begin()->get_val());}

void test_refwrap_to_value() {    std::vector<my_movable> vec{};    vec.emplace_back(41);    vec.emplace_back(42);    vec.emplace_back(43);        auto transformed = sl::ranges::transform(sl::ranges::refwrap(vec), [](my_movable& el) {        return std::move(el);    });    auto filtered = sl::ranges::filter(std::move(transformed), [](my_movable& el) {        return 42 != el.get_val();    }, sl::ranges::ignore_offcast<my_movable>);        auto res = filtered.to_vector();    slassert(2 == res.size());    slassert(41 == res[0].get_val());    slassert(43 == res[1].get_val());    slassert(3 == vec.size());    slassert(-1 == vec[0].get_val());    slassert(-1 == vec[1].get_val());    slassert(-1 == vec[2].get_val());}

 /** Setup fixture */ corrected_intensity_write_read_fixture_v2() {     typedef metric_type::uint_t uint_t;     typedef metric_type::ushort_t ushort_t;     ushort_t correctedIntAll1[] = {1213, 966, 960, 1095};     ushort_t correctedIntCalled1[] = {4070, 4074, 4029, 3972};     uint_t calledCounts1[] = {0, 698433, 548189, 548712, 646638};     expected_metrics.push_back(             metric_type(1, 1104, 25, 1063, 11.9458876f, to_vector(correctedIntCalled1), to_vector(correctedIntAll1),                         to_vector(calledCounts1)));     ushort_t correctedIntAll2[] = {1558, 1151, 1158, 1293};     uint_t calledCounts2[] = {10938, 733661, 537957, 543912, 615504};     ushort_t correctedIntCalled2[] = {5013, 4983, 4915, 4932};     expected_metrics.push_back(             metric_type(1, 1104, 1, 1295, 13.3051805f, to_vector(correctedIntCalled2), to_vector(correctedIntAll2),                         to_vector(calledCounts2)));     ushort_t correctedIntAll3[] = {1171, 932, 912, 1069};     uint_t calledCounts3[] = {0, 706987, 556441, 556067, 653959};     ushort_t correctedIntCalled3[] = {3931, 3931, 3923, 3878};     expected_metrics.push_back(             metric_type(1, 1105, 25, 1025, 11.7396259f, to_vector(correctedIntCalled3), to_vector(correctedIntAll3),                         to_vector(calledCounts3)));     setup_write_read(); }

//.........这里部分代码省略.........        }        if (CFSAString("-utt") == argv[i]) {            print_utt = true;        }                if (CFSAString("-raw") == argv[i]) {            write_raw = true;        }        if (CFSAString("-dur") == argv[i]) {            if (i + 1 < argc) {                dur_fname = argv[i + 1];                cfileexists(dur_fname);                write_durlabel = true;                            } else {                fprintf(stderr, "Viga: puudb kestustefaili nimi/n");                PrintUsage();                exit(0);            }        }            }    Linguistic.Open(LexFileName);    Disambiguator.Open(LexDFileName);    CFSWString text;    ReadUTF8Text(text, in_fname);    HTS_Engine_initialize(&engine);    if (HTS_Engine_load(&engine, fn_voices, 1) != TRUE) {        fprintf(stderr, "Viga: puudub *.htsvoice. %p/n", fn_voices[0]);        free(fn_voices);        HTS_Engine_clear(&engine);        exit(1);    }    free(fn_voices);    HTS_Engine_set_sampling_frequency(&engine, (size_t) fr);    HTS_Engine_set_phoneme_alignment_flag(&engine, FALSE);    HTS_Engine_set_fperiod(&engine, (size_t) fp);    HTS_Engine_set_alpha(&engine, alpha);    HTS_Engine_set_beta(&engine, beta);    HTS_Engine_set_speed(&engine, speed);    HTS_Engine_add_half_tone(&engine, ht);    HTS_Engine_set_msd_threshold(&engine, 1, th);    /*    HTS_Engine_set_duration_interpolation_weight(&engine, 1, diw);    HTS_Engine_set_parameter_interpolation_weight(&engine, 0, 0, piw1);    HTS_Engine_set_parameter_interpolation_weight(&engine, 0, 1, piw2);    HTS_Engine_set_gv_interpolation_weight(&engine, 0, 0, giw1);    HTS_Engine_set_gv_interpolation_weight(&engine, 0, 1, giw2);     */    HTS_Engine_set_gv_weight(&engine, 0, gvw1);    HTS_Engine_set_gv_weight(&engine, 1, gvw2);    text = DealWithText(text);    CFSArray<CFSWString> res = do_utterances(text);    INTPTR data_size = 0;    outfp = fopen(output_fname, "wb");    if (write_durlabel) durfp = fopen(dur_fname, "w");    if (!write_raw) HTS_Engine_write_header(&engine, outfp, 1);    for (INTPTR i = 0; i < res.GetSize(); i++) {        CFSArray<CFSWString> label = do_all(res[i], print_label, print_utt);        std::vector<std::string> v;        v = to_vector(label);        std::vector<char*> vc;        fill_char_vector(v, vc);        size_t n_lines = vc.size();        if (HTS_Engine_synthesize_from_strings(&engine, &vc[0], n_lines) != TRUE) {            fprintf(stderr, "Viga: süntees ebaonnestus./n");                        HTS_Engine_clear(&engine);            exit(1);        }        clean_char_vector(vc);        data_size += HTS_Engine_engine_speech_size(&engine);        if (write_durlabel) HTS_Engine_save_durlabel(&engine, durfp);        HTS_Engine_save_generated_speech(&engine, outfp);        HTS_Engine_refresh(&engine);    } //synth loop        if (!write_raw) HTS_Engine_write_header(&engine, outfp, data_size);    if (write_durlabel) fclose(durfp);    fclose(outfp);    HTS_Engine_clear(&engine);    Linguistic.Close();    FSCTerminate();    return 0;}

#include <examples.h>const std::vector<int> vec1to4 = iota(1) | limit(4) | to_vector();const std::vector<int> vec5to8 = iota(5) | limit(4) | to_vector();const std::vector<int> vec1to8 = iota(1) | limit(8) | to_vector();int main(int argc, char** argv) {    std::cout << "flow examples" << std::endl << std::endl;    std::cout << "vec1to4 = ";    vec1to4 | dump();    std::cout << std::endl << "vec5to8 = ";    vec5to8 | dump();    std::cout << std::endl << std::endl;    concat_example();    drop_while_example();    zip_example();    terminal_example();    system("pause");    return 0;}

/* * Counts occurrences of three-node functional motifs in a weighted graph. * Returns intensity and (optionally) coherence and motif counts. */MATRIX_T* BCT_NAMESPACE::motif3funct_wei(const MATRIX_T* W, MATRIX_T** Q, MATRIX_T** F) {	if (safe_mode) check_status(W, SQUARE | WEIGHTED, "motif3funct_wei");		// load motif34lib M3 M3n ID3 N3	VECTOR_T* ID3;	VECTOR_T* N3;	MATRIX_T* M3 = motif3generate(&ID3, &N3);		// n=length(W);	int n = length(W);		// I=zeros(13,n);	MATRIX_T* I = zeros(13, n);		// Q=zeros(13,n);	if (Q != NULL) {		*Q = zeros(13, n);	}		// F=zeros(13,n);	if (F != NULL) {		*F = zeros(13, n);	}		// A=1*(W~=0);	MATRIX_T* A = compare_elements(W, fp_not_equal, 0.0);		// As=A|A.';	MATRIX_T* A_transpose = MATRIX_ID(alloc)(A->size2, A->size1);	MATRIX_ID(transpose_memcpy)(A_transpose, A);	MATRIX_T* As = logical_or(A, A_transpose);	MATRIX_ID(free)(A_transpose);		// for u=1:n-2	for (int u = 0; u < n - 2; u++) {				// V1=[false(1,u) As(u,u+1:n)];		VECTOR_T* V1 = VECTOR_ID(alloc)(n);		MATRIX_ID(get_row)(V1, As, u);		for (int i = 0; i <= u; i++) {			VECTOR_ID(set)(V1, i, 0.0);		}				// for v1=find(V1)		VECTOR_T* find_V1 = find(V1);		if (find_V1 != NULL) {			for (int i_find_V1 = 0; i_find_V1 < (int)find_V1->size; i_find_V1++) {				int v1 = (int)VECTOR_ID(get)(find_V1, i_find_V1);								// V2=[false(1,u) As(v1,u+1:n)];				VECTOR_T* V2 = VECTOR_ID(alloc)(n);				MATRIX_ID(get_row)(V2, As, v1);				for (int i = 0; i <= u; i++) {					VECTOR_ID(set)(V2, i, 0.0);				}								// V2(V1)=0;				logical_index_assign(V2, V1, 0.0);								// V2=([false(1,v1) As(u,v1+1:n)])|V2;				VECTOR_T* V2_1 = VECTOR_ID(alloc)(n);				MATRIX_ID(get_row)(V2_1, As, u);				for (int i = 0; i <= v1; i++) {					VECTOR_ID(set)(V2_1, i, 0.0);				}				VECTOR_T* V2_2 = V2;				V2 = logical_or(V2_1, V2_2);				VECTOR_ID(free)(V2_1);				VECTOR_ID(free)(V2_2);								// for v2=find(V2)				VECTOR_T* find_V2 = find(V2);				if (find_V2 != NULL) {					for (int i_find_V2 = 0; i_find_V2 < (int)find_V2->size; i_find_V2++) {						int v2 = (int)VECTOR_ID(get)(find_V2, i_find_V2);												// w=[W(v1,u) W(v2,u) W(u,v1) W(v2,v1) W(u,v2) W(v1,v2)];						int WA_rows[] = { v1, v2, u, v2, u, v1 };						int WA_cols[] = { u, u, v1, v1, v2, v2 };						VECTOR_T* w = VECTOR_ID(alloc)(6);						for (int i = 0; i < 6; i++) {							VECTOR_ID(set)(w, i, MATRIX_ID(get)(W, WA_rows[i], WA_cols[i]));						}												// a=[A(v1,u);A(v2,u);A(u,v1);A(v2,v1);A(u,v2);A(v1,v2)];						MATRIX_T* a = MATRIX_ID(alloc)(6, 1);						for (int i = 0; i < 6; i++) {							MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, WA_rows[i], WA_cols[i]));						}												// ind=(M3*a)==N3;						MATRIX_T* M3_mul_a_m = mul(M3, a);						MATRIX_ID(free)(a);						VECTOR_T* M3_mul_a = to_vector(M3_mul_a_m);						MATRIX_ID(free)(M3_mul_a_m);						VECTOR_T* ind = compare_elements(M3_mul_a, fp_equal, N3);//.........这里部分代码省略.........

//.........这里部分代码省略.........						VECTOR_ID(free)(V3_2);												// V3(V1)=0;						logical_index_assign(V3, V1, 0.0);												// V3=V3|([false(1,vz) As(u,vz+1:n)]);						V3_1 = V3;						V3_2 = VECTOR_ID(alloc)(n);						MATRIX_ID(get_row)(V3_2, As, u);						for (int i = 0; i <= vz; i++) {							VECTOR_ID(set)(V3_2, i, 0.0);						}						V3 = logical_or(V3_1, V3_2);						VECTOR_ID(free)(V3_1);						VECTOR_ID(free)(V3_2);												// for v3=find(V3)						VECTOR_T* find_V3 = find(V3);						if (find_V3 != NULL ) {							for (int i_find_V3 = 0; i_find_V3 < (int)find_V3->size; i_find_V3++) {								int v3 = (int)VECTOR_ID(get)(find_V3, i_find_V3);																// a=[A(v1,u);A(v2,u);A(v3,u);A(u,v1);A(v2,v1);A(v3,v1);A(u,v2);A(v1,v2);A(v3,v2);A(u,v3);A(v1,v3);A(v2,v3)];								int A_rows[] = { v1, v2, v3, u, v2, v3, u, v1, v3, u, v1, v2 };								int A_cols[] = { u, u, u, v1, v1, v1, v2, v2, v2, v3, v3, v3 };								MATRIX_T* a = MATRIX_ID(alloc)(12, 1);								for (int i = 0; i < 12; i++) {									MATRIX_ID(set)(a, i, 0, MATRIX_ID(get)(A, A_rows[i], A_cols[i]));								}																// ind=(M4*a)==N4;								MATRIX_T* M4_mul_a_m = mul(M4, a);								MATRIX_ID(free)(a);								VECTOR_T* M4_mul_a = to_vector(M4_mul_a_m);								MATRIX_ID(free)(M4_mul_a_m);								VECTOR_T* ind = compare_elements(M4_mul_a, fp_equal, N4);								VECTOR_ID(free)(M4_mul_a);																// id=ID4(ind);								VECTOR_T* id = logical_index(ID4, ind);								VECTOR_ID(free)(ind);								if (id != NULL) {									VECTOR_ID(add_constant)(id, -1.0);																	// [idu j]=unique(id);									VECTOR_T* j;									VECTOR_T* idu = unique(id, "last", &j);									VECTOR_ID(free)(id);																		// j=[0;j];									VECTOR_T* temp = VECTOR_ID(alloc)(j->size + 1);									VECTOR_ID(set)(temp, 0, -1.0);									VECTOR_ID(view) temp_subv = VECTOR_ID(subvector)(temp, 1, j->size);									VECTOR_ID(memcpy)(&temp_subv.vector, j);									VECTOR_ID(free)(j);									j = temp;																		// mu=length(idu);									int mu = length(idu);																		// f2=zeros(mu,1);									VECTOR_T* f2 = zeros_vector(mu);																		// for h=1:mu									for (int h = 0; h < mu; h++) {										

 /**  * Same as head, return vector<flexible_type>, used for testing.  */ std::vector<flexible_type> _head(size_t nrows) {   auto result = head(nrows);   auto ret = result->to_vector();   return ret; }

 std::vector<flexible_type> _tail(size_t nrows=10) {   auto result = tail(nrows);   auto ret = result->to_vector();   return ret; }