Ejemplos de row_major en C++ (Cpp)

Ejemplo n.º 1

Archivo: matrix_assign.hpp Proyecto: Ulfgard/aBLAS

void assign(
    matrix_expression<M,cpu_tag> &m,
    matrix_expression<E,cpu_tag> const& e,
    typename M::value_type alpha,
    row_major, unknown_orientation ,TagE tagE, TagM tagM
) {
    assign<F> (m,e,alpha, row_major(),row_major(),tagE,tagM);
}

Ejemplo n.º 2

Archivo: gemv.hpp Proyecto: Shark-ML/Shark

void gemv_impl(
	matrix_expression<MatA, cpu_tag> const& A,
	vector_expression<V, cpu_tag> const& x,
	vector_expression<ResultV, cpu_tag>& result,
	typename ResultV::value_type alpha,
	unknown_orientation
) {
	gemv_impl(A,x,result,alpha,row_major());
}

Ejemplo n.º 3

Archivo: sum_rows.hpp Proyecto: inglada/Shark

void sum_rows(
	matrix_expression<M, Device> const & A, 
	vector_expression<V, Device>& b,
	typename V::value_type alpha,
	unknown_orientation,
	Tag1, Tag2
){
	sum_rows(A,b,alpha,row_major(), Tag1(), Tag2());
}

Ejemplo n.º 4

Archivo: cali-memtracking.cpp Proyecto: alfredo-gimenez/Caliper

void do_work(size_t M, size_t W, size_t N)
{
    size_t i, j, k;

    cali::Annotation alloc_phase(cali::Annotation("phase").begin("allocate"));

    const size_t dimA[] = { M, W };
    const size_t dimB[] = { W, N };
    const size_t dimC[] = { M, N };

    double *matA = 
        (double*) cali_datatracker_allocate_dimensional("A", sizeof(double), dimA, 2);
    double *matB =
        (double*) cali_datatracker_allocate_dimensional("B", sizeof(double), dimB, 2);
    double *matC =
        (double*) cali_datatracker_allocate_dimensional("C", sizeof(double), dimC, 2);

    alloc_phase.end();
    cali::Annotation init_phase(cali::Annotation("phase").begin("initialize_values"));

    // Initialize A and B randomly
    for (i = 0; i < M; i++)
        for(k = 0; k < W; k++)
            matA[row_major(i,k,M)] = rand();

    for(k = 0; k < W; k++)
        for(j = 0; j < N; j++)
            matB[row_major(k,j,W)] = rand();

    init_phase.end();
    cali::Annotation mul_phase(cali::Annotation("phase").begin("multiply"));

    // AB = C
    for (i = 0; i < M; i++)
        for(j = 0; j < N; j++)
            for(k = 0; k < W; k++)
                matC[row_major(i,j,M)] += matA[row_major(i,k,M)] * matB[row_major(k,j,W)];

    mul_phase.end();
    cali::Annotation sum_phase(cali::Annotation("phase").begin("sum"));

    // Print sum of elems in C
    double cSum = 0;
    for (i = 0; i < M; i++)
        for(j = 0; j < N; j++)
            cSum += matC[row_major(i,j,M)];

    std::cout << "cSum = " << cSum << std::endl;

    sum_phase.end();
    cali::Annotation free_phase(cali::Annotation("phase").begin("free"));

    cali_datatracker_free(matA);
    cali_datatracker_free(matB);
    cali_datatracker_free(matC);

    free_phase.end();
}

Ejemplo n.º 5

Archivo: sparse_rc.hpp Proyecto: iagomosqueira/FLasher

	/// row-major order
	SizeVector row_major(void) const
	{	SizeVector keys(nnz_), row_major(nnz_);
		for(size_t k = 0; k < nnz_; k++)
		{	CPPAD_ASSERT_UNKNOWN( row_[k] < nr_ );
			keys[k] = row_[k] * nc_ + col_[k];
		}
		index_sort(keys, row_major);
# ifndef NDEBUG
		for(size_t ell = 0; ell + 1 < nnz_; ell++)
		{	size_t k  = row_major[ ell ];
			size_t kp = row_major[ ell + 1 ];
			CPPAD_ASSERT_KNOWN(
				row_[k] != row_[kp] || col_[k] != col_[kp],
				"sparse_rc: row_major: duplicate entry in this pattern"
			);
			CPPAD_ASSERT_UNKNOWN(
				row_[k]<row_[kp] || (row_[k]==row_[kp] && col_[k]<col_[kp])
			);
		}
# endif
		return row_major;
	}