RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/matrix_8hpp_source.html below:

NCBI C++ ToolKit: include/util/math/matrix.hpp Source File

1 #ifndef UTIL_MATH___MATRIX__HPP 2 #define UTIL_MATH___MATRIX__HPP 151 template

<

class

T,

class

U>

158 template

<

class

T,

class

U>

198 template

<

class

T,

class

U>

205 template

<

class

T,

class

U>

212 template

<

class

T,

class

U>

219 template

<

class

T,

class

U>

226 template

<

class

T,

class

U>

233 template

<

class

T,

class

U>

240 template

<

class

T,

class

U>

261 template

<

class

T,

class

U>

268 template

<

class

T,

class

U>

327 return

m_Data.begin();

341 return

m_Data.begin();

375 return

m_Data[

i

* m_Cols + j];

385 return

m_Data[

i

* m_Cols + j];

393 if

(new_cols == m_Cols && new_rows >= m_Rows) {

395

m_Data.resize(new_rows * new_cols,

);

399 TData

new_data(new_rows * new_cols,

);

400 size_t i

=

(new_rows, m_Rows);

401 size_t

j =

(new_cols, m_Cols);

403 for

(

size_t r

= 0;

r

<

i

; ++

r

) {

404 for

(

size_t

c = 0; c < j; ++c) {

405

new_data[

r

* new_cols + c] = m_Data[

r

* m_Cols + c];

409

new_data.swap(m_Data);

420

m_Data.resize(m_Rows * m_Cols,

);

430 for

(

size_t i

= 0;

i

< m_Rows; ++

i

) {

431

m_Data[

i

* m_Cols +

i

] =

T

(1);

442 for

(

size_t i

= 0;

i

< m_Rows; ++

i

) {

443

m_Data[

i

* m_Cols +

i

] =

T

(1);

454 for

(

size_t i

= 0;

i

< m_Rows; ++

i

) {

455

m_Data[

i

* m_Cols +

i

] =

;

466 for

(

size_t i

= 0;

i

< m_Rows; ++

i

) {

467

m_Data[

i

* m_Cols +

i

] =

;

475 TData

new_data(m_Cols * m_Rows);

477 for

(

size_t i

= 0;

i

< m_Rows; ++

i

) {

478 for

(

size_t

j = 0; j < m_Cols; ++j) {

479

new_data[j * m_Cols +

i

] = m_Data[

i

* m_Cols + j];

483

m_Data.swap(new_data);

484 swap

(m_Rows, m_Cols);

491 size_t

i_offs =

i

* m_Cols;

492 size_t

j_offs = j * m_Cols;

494 for

(

size_t

c = 0; c < m_Cols; ++c) {

495 swap

(m_Data[i_offs + c], m_Data[j_offs + c] );

503

m_Data.swap(

M

.m_Data);

504 swap

(m_Cols,

M

.m_Cols);

505 swap

(m_Rows,

M

.m_Rows);

513 for

(++

r

;

r

< m_Rows; ++

r

) {

514 for

(

size_t

c = 0; c < m_Cols; ++c) {

515

m_Data[(

r

- 1) * m_Cols + c] = m_Data[

r

* m_Cols + c];

520

m_Data.resize(m_Rows * m_Cols);

528 for

(

size_t r

= 0;

r

< m_Rows; ++

r

) {

529 for

(

size_t

c = col + 1; c < m_Cols; ++c) {

530

m_Data[

r

* m_Cols + c - 1] = m_Data[

r

* m_Cols + c];

534

Resize(m_Rows, m_Cols - 1);

546 template

<

class

T,

class

U>

560 for

( ; res_iter != res_end; ++res_iter, ++m0_iter, ++m1_iter) {

561

*res_iter = *m0_iter + *m1_iter;

568 template

<

class

T,

class

U>

580 for

( ;

; --

, ++m0_iter, ++m1_iter) {

581

*m0_iter += *m1_iter;

584 for

( ; m0_iter != m0_end; ) {

585

*m0_iter++ += *m1_iter++;

586

*m0_iter++ += *m1_iter++;

587

*m0_iter++ += *m1_iter++;

588

*m0_iter++ += *m1_iter++;

599 template

<

class

T,

class

U>

612 for

( ; res_iter != res_end; ++res_iter, ++m0_iter, ++m1_iter) {

613

*res_iter = *m0_iter - *m1_iter;

620 template

<

class

T,

class

U>

631 for

( ; m0_iter != m0_end; ++m0_iter, ++m1_iter) {

632

*m0_iter -= *m1_iter;

652 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

653

*res_iter = *m0_iter *

;

670 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

671

*res_iter = *m0_iter *

;

688 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

689

*res_iter = *m0_iter *

;

706 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

707

*res_iter = *m0_iter *

;

724 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

725

*res_iter = *m0_iter *

;

742 for

( ; res_iter != res_end; ++res_iter, ++m0_iter) {

743

*res_iter = *m0_iter *

;

757 for

( ; m0_iter != m0_end; ++m0_iter) {

774 for

( ; m0_iter != m0_end; ++m0_iter) {

782 template

<

class

T,

class

U>

789

vector< TPromote > res(m.

(), TPromote(0));

791 for

(

size_t r

= 0;

r

< m.

(); ++

r

) {

792 for

(

size_t i

= 0;

i

< m.

(); ++

i

) {

793

res[

r

] += m(

r

,

i

) * v[

i

];

801 template

<

class

T,

class

U>

808

vector<TPromote> res(m.

(), TPromote(0));

810 for

(

size_t

c = 0; c < m.

(); ++c) {

811 for

(

size_t i

= 0;

i

< m.

(); ++

i

) {

812

res[c] += m(

i

,c) * v[

i

];

820 template

<

class

T,

class

U>

830 for

(

size_t r

= 0;

r

< m0.

(); ++

r

) {

831 for

(

size_t

c = 0; c < m1.

(); ++c) {

832 for

(

size_t i

= 0;

i

< m0.

(); ++

i

) {

833

res(

r

,c) += m0(

r

,

i

) * m1(

i

,c);

841 const

vector<T>& lhs = m0.

();

842 const

vector<U>& rhs = m1.

();

843 size_t

col_mod = m0.

() % 4;

845 for

(

size_t r

= 0;

r

< m0.

(); ++

r

) {

848 for

(

size_t

c = 0; c < m1.

(); ++c) {

861

t0 += m0.

()[r_offs + 2] * m1(2,c);

864

t0 += m0.

()[r_offs + 1] * m1(1,c);

867

t0 += m0.

()[r_offs + 0] * m1(0,c);

873

t0 += lhs[r_offs +

i

+ 0] * m1(

i

+ 0, c);

874

t1 += lhs[r_offs +

i

+ 1] * m1(

i

+ 1, c);

878

res(

r

,c) = t0 + t1 + t2 + t3;

887 template

<

class

T,

class

U>

902 template

<

class

T,

class

U>

914 if

(m0[

i

] != m1[

i

]) {

923 template

<

class

T,

class

U>

936 for

(

size_t i

= 0;

i

<

M

.GetRows(); ++

i

) {

937 for

(

size_t

j = 0; j <

M

.GetCols(); ++j) {

959 while

(getline(is, line)) {

961 if

(line.empty() || line[0] ==

'#'

) {

971 row

.push_back(entry);

973 if

(

A

.GetCols() == 0) {

974 A

.Resize(

A

.GetCols(),

.size());

976 if

(

.size() !=

A

.GetCols()) {

983 A

.Resize(

A

.GetRows() + 1,

A

.GetCols());

984 for

(

int i

= 0;

i

<

A

.GetCols(); ++

i

) {

985 A

(

A

.GetRows() - 1,

i

) =

[

i

];

void Resize(size_t i, size_t j, T val=T())

resize this matrix, filling the empty cells with a known value

TData & GetData()

retrieve the data associated with this matrix

void Diagonal(size_t size, T val)

make this matrix a diagonal matrix of a given size, with a given value on the diagonal

void SwapRows(size_t i, size_t j)

swap two rows in the matrix

const T & operator[](size_t i) const

operator[] for raw data indexing

void Swap(CNcbiMatrix< T > &M)

swap two matrices efficiently

const_iterator begin() const

void Identity()

make this matrix an identity matrix

void Set(T val)

set all values in the matrix to a known value

void RemoveRow(size_t i)

remove a given row in the matrix

size_t m_Rows

size of this matrix

void Identity(size_t size)

make this matrix an identity matrix of a given size

size_t GetRows() const

get the number of rows in this matrix

TData::const_iterator const_iterator

void RemoveCol(size_t i)

remove a given column in the matrix

const T & operator()(size_t i, size_t j) const

operator() for row/column indexing

size_t GetCols() const

get the number of columns in this matrix

CNcbiMatrix(size_t r, size_t c, T val=T())

void Diagonal(T val)

make this matrix a diagonal matrix, with a given value on the diagonal

void Transpose()

transpose this matrix

CNcbiMatrix()

default ctor

const TData & GetData() const

const_iterator end() const

iterator begin()

iterators

TData m_Data

the data strip we use

Include a standard set of the NCBI C++ Toolkit most basic headers.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

NCBI_PROMOTE(T, U) operator*(const CVect2< T > &v1

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ostream CNcbiOstream

Portable alias for ostream.

IO_PREFIX::istream CNcbiIstream

Portable alias for istream.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

CNcbiMatrix< NCBI_PROMOTE(T, size_t) > operator*(const CNcbiMatrix< T > &, size_t)

global multiplication: matrix * scalar this is a hack, as MSVC doesn't support partial template speci...

CNcbiMatrix< T > & operator+=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global addition: matrix += matrix

CNcbiMatrix< T > & operator*=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global multiplication: matrix *= matrix

CNcbiIstream & operator>>(CNcbiIstream &is, CNcbiMatrix< T > &M)

global operators

CNcbiMatrix< T > & operator-=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global subtraction: matrix -= matrix

bool operator==(const CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global comparison: matrix == matrix

CNcbiMatrix< T > & operator/=(CNcbiMatrix< T > &, T)

global division: matrix /= matrix

CNcbiOstream & operator<<(CNcbiOstream &os, const CNcbiMatrix< T > &M)

stream output.

CNcbiMatrix< NCBI_PROMOTE(T, U) > operator-(const CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global subtraction: matrix - matrix

CNcbiMatrix< NCBI_PROMOTE(T, U) > operator+(const CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global addition: matrix + matrix

bool operator!=(const CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global comparison: matrix != matrix

const struct ncbi::grid::netcache::search::fields::SIZE size

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

#define row(bind, expected)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4