BOOST_FORCEINLINE result_type operator()(Expr& e) const
{
BOOST_ASSERT_MSG((isscalar( boost::proto::child_c<0>(e))&&issquare(boost::proto::child_c<1>(e)))||
(isscalar( boost::proto::child_c<1>(e))&&issquare(boost::proto::child_c<0>(e))),
"mpower needs a square matrix expression and a scalar or a scalar and a square matrix expression");
return nt2::utility::max_extent(nt2::extent(boost::proto::child_c<0>(e)), nt2::extent(boost::proto::child_c<1>(e)));
}
schur_result ( Input& xpr
, char jobvs/* = 'V'*/
, char sort /* = 'N'*/
, char sense/* = 'N'*/)
: jobvs_(jobvs)
, sort_(sort)
, sense_(sense)
, a_(xpr)
, aa_(xpr)
, n_(nt2::height(xpr))
, lda_(a_.leading_size())
{
BOOST_ASSERT_MSG(issquare(aa_), "Error using schur. Matrix must be square.");
jobvs_ = (sense_ == 'E' || sense_ == 'B') ? 'V':jobvs_;
sort_ = (sense_ == 'E') ? 'S' : sort_;
ldvs_ = (jobvs_ == 'V') ? n_ : 1;
w_.resize(nt2::of_size(n_, 1));
vs_.resize(of_size(ldvs_, ldvs_));
ldvs_ = vs_.leading_size();
nt2::details::geesx(&jobvs_, &sort_, &nt2::details::selectall , &sense_, &n_,
aa_.raw(), &lda_, &sdim_, w_.raw(),
vs_.raw(), &ldvs_,
&rconde_, &rcondv_,
&info_, wrk_);
}
balance_result ( Input& xpr, char job/* = 'B'*/)
: job_(job)
, a_(xpr)
, aa_(xpr)
, ipi_(of_size(0, 0))
, n_( nt2::height(a_) )
, lda_( a_.leading_size() )
, t_(of_size(n_, n_))
, invt_(of_size(0, 0))
, ilo_(0)
, ihi_(0)
, scale_(of_size(1, n_))
, info_(0)
{
BOOST_ASSERT_MSG(issquare(aa_),
"matrix to balance must be square");
nt2::details::gebal(&job_, &n_, aa_.raw(), &lda_,
&ilo_, &ihi_, scale_.raw(),
&info_);
t_ = nt2::eye(n_, n_, meta::as_<type_t>());
nt2_la_int ldt = t_.leading_size();
char side = 'R';
nt2::details::gebak(&job_, &side, &n_,
&ilo_, &ihi_, scale_.raw(),
&n_, t_.raw(), &ldt, &info_);
}
void eu066(char *ans) {
const int N = 1000;
int d_of_max = 0;
mpz_t x, max;
mpz_init(x);
mpz_init(max);
mpz_set_ui(max, 0);
for (int d = 1; d < N; d++) {
if (issquare(d)) continue;
minx(d, x);
if (mpz_cmp(x, max) > 0) {
mpz_set(max, x);
d_of_max = d;
}
}
mpz_clear(x);
mpz_clear(max);
sprintf(ans, "%d", d_of_max);
}
BOOST_FORCEINLINE result_type operator()(Expr& e) const
{
BOOST_ASSERT_MSG((issquare(boost::proto::child_c<0>(e))),
"impower needs a square matrix expression and a scalar integer");
return nt2::extent(boost::proto::child_c<0>(e));
}
/**
* @brief Eigenvalue decomposition
*
* Usage:
* @code{.cpp}
* Matrix<cxfl> m = rand<cxfl> (10,10), ev;
* Matrix<float> lv, rv;
* boost::tuple<Matrix<float>,Matrix<cxfl>,Matrix<float>> ler
* ler = eig2 (m);
* lv = boost::get<0>(ler)
* ev = boost::get<1>(ler);
* rv = boost::get<2>(ler)
* @endcode
* where m is the complex decomposed matrix, lv and rv are the left hand and right
* hand side eigen vectors and ev is the eigenvalue vector.
*
* @see LAPACK driver xGEEV
*
* @param m Matrix for decomposition
* @param jobvl Compute left vectors ('N'/'V')
* @param jobvr Compute right vectors ('N'/'V')
* @return Eigenvectors and values
*/
template <class T, class S> inline boost::tuple< Matrix<T>, Matrix<S>, Matrix<T> >
eig2 (const Matrix<T>& m, char jobvl = 'N', char jobvr = 'N') {
typedef typename LapackTraits<T>::RType T2;
T t;
boost::tuple< Matrix<T>, Matrix<S>, Matrix<T> > ret;
assert (jobvl == 'N' || jobvl =='V');
assert (jobvr == 'N' || jobvr =='V');
assert (issquare(m));
int N = size(m, 0);
int lda = N;
int ldvl = (jobvl == 'V') ? N : 1;
int ldvr = (jobvr == 'V') ? N : 1;
int info = 0;
int lwork = -1;
// Appropriately resize the output
boost::get<1>(ret) = Matrix<S>(N,1);
if (jobvl == 'V') boost::get<0>(ret) = Matrix<T>(N,N);
if (jobvr == 'V') boost::get<2>(ret) = Matrix<T>(N,N);
Matrix<S>& ev = boost::get<1>(ret);
Matrix<T> &lv = boost::get<0>(ret), &rv = boost::get<2>(ret);
// Workspace for real numbers
container<T2> rwork = (is_complex(t)) ?
container<T2>(2*N) : container<T2>(1);
// Workspace for complex numbers
container<T> work = container<T>(1);
// Need copy. Lapack destroys A on output.
Matrix<T> a = m;
// Work space query
LapackTraits<T>::geev (jobvl, jobvr, N, &a[0], lda, &ev[0], &lv[0], ldvl, &rv[0], ldvr, &work[0], lwork, &rwork[0], info);
// Initialize work space
lwork = (int) TypeTraits<T>::Real (work[0]);
work.resize(lwork);
// Actual Eigenvalue computation
LapackTraits<T>::geev (jobvl, jobvr, N, &a[0], lda, &ev[0], &lv[0], ldvl, &rv[0], ldvr, &work[0], lwork, &rwork[0], info);
if (info > 0) {
printf ("\nERROR - XGEEV: the QR algorithm failed to compute all the\n eigenvalues, and no eigenvectors have " \
"been computed;\n elements %d+1:N of ev contain eigenvalues which\n have converged.\n\n", info) ;
} else if (info < 0)
printf ("\nERROR - XGEEV: the %d-th argument had an illegal value.\n\n", -info);
return ret;
}
int main()
{
unsigned n;
printf("Enter a number:\n");
scanf(" %u%*c", &n);
printf("The number is %sperfect square.\n", issquare(n)?"":"not ");
return 0;
}
cholesky_result ( char uplo, Input& xpr )
: values_(xpr)
, height_( nt2::height(xpr) )
, leading_( values_.leading_size() )
, info_(0)
, uplo_(uplo)
{
BOOST_ASSERT_MSG(issquare(values_), "matrix must be square");
nt2::details::potrf ( &uplo_, &height_
, values_.raw(), &leading_, &info_
);
}
int main(int argc, char *argv[]) {
int n, aux, t, i;
scanf("%d", &n);
t = 0;
for (i = 0; i < n; ++i) {
scanf("%d", &aux);
if (issquare(aux))
t += aux;
}
printf("%d\n", t);
return 0;
}
/**
* @brief Invert quadratic well conditioned matrix
*
* Usage:
* @code{.cpp}
* Matrix<cxfl> m = rand<cxfl> (10,10);
*
* m = inv (m);
* @endcode
*
* @see Lapack xGETRF/xGETRI
*
* @param m Matrix
* @return Inverse
*/
template <class T> inline Matrix<T>
inv (const Matrix<T>& m) {
// 2D
assert(issquare(m));
int N = (int) size (m,0);
Matrix<T> res = m;
int info = 0;
container<int> ipiv = container<int>(N);
// LU Factorisation -------------------
LapackTraits<T>::getrf (N, N, &res[0], N, &ipiv[0], info);
if (info < 0)
printf ("\nERROR - DPOTRI: the %i-th argument had an illegal value.\n\n", -info);
else if (info > 1)
printf ("\nERROR - DPOTRI: the (%i,%i) element of the factor U or L is\n zero, and the inverse could not be " \
"computed.\n\n", info, info);
int lwork = -1;
container<T> work = container<T>(1);
// Workspace determination ------------
LapackTraits<T>::getri (N, &res[0], N, &ipiv[0], &work[0], lwork, info);
// Work memory allocation -------------
lwork = (int) TypeTraits<T>::Real (work[0]);
work.resize(lwork);
// Inversion --------------------------
LapackTraits<T>::getri (N, &res[0], N, &ipiv[0], &work[0], lwork, info);
if (info < 0)
printf ("\nERROR - XGETRI: The %i-th argument had an illegal value.\n\n", -info);
else if (info > 0)
printf ("\nERROR - XGETRI: The leading minor of order %i is not\n positive definite, and the factorization could " \
"not be\n completed.", info);
return res;
}
BOOST_FORCEINLINE result_type operator()(Expr& e) const
{
BOOST_ASSERT_MSG( issquare(boost::proto::child_c<1>(e)),
"funm needs a functor and scalar or a ");
return nt2::extent(boost::proto::child_c<1>(e));
}
int ft_isvalid(const char *tab, int len)
{
if (!issquare(tab, len) || !hasfour(tab) || !ischar(tab) || !doestouch(tab))
return (0);
return (1);
}
BOOST_FORCEINLINE result_type operator()(Expr& e) const
{
BOOST_ASSERT_MSG(issquare(boost::proto::child_c<0>(e)),
"logm needs a square matrix or a scalar");
return nt2::extent(boost::proto::child_c<0>(e));
}
