BasicArray middleRows(int start, int n) {
BasicArray out;
out.resize(n, m_nCol);
for (int i = start; i < start + n; ++i) {
for (int j = 0; j < m_nCol; ++j) {
out(i, j) = at(i, j);
}
}
return out;
}
BasicArray block(int startRow, int startCol, int nRow, int nCol) const {
BasicArray out;
out.resize(nRow, nCol);
for (int iRow = 0; iRow < nRow; ++iRow) {
for (int iCol = 0; iCol < nCol; ++iCol) {
out(iRow, iCol) = at(iRow + startRow, iCol + startCol);
}
}
return out;
}
BasicArray<QuadExpr> exprMult(const Eigen::MatrixXd& A, const BasicArray<QuadExpr>& B) {
BasicArray<QuadExpr> C(A.rows(), B.cols());
assert(A.cols() == B.rows());
int m = A.cols();
for (int i=0; i<A.rows(); i++) {
for (int j=0; j<B.cols(); j++) {
C(i,j) = QuadExpr();
for (int k=0; k<m; k++)
C(i,j) = C(i,j) + A(i,k)*B(k,j);
}
}
return C;
}
BasicColumn<T>::BasicColumn(Allocator& alloc, ref_type ref)
{
char* header = alloc.translate(ref);
bool root_is_leaf = !Array::get_is_inner_bptree_node_from_header(header);
if (root_is_leaf) {
BasicArray<T>* root = new BasicArray<T>(alloc); // Throws
root->init_from_mem(MemRef(header, ref));
m_array = root;
}
else {
Array* root = new Array(alloc); // Throws
root->init_from_mem(MemRef(header, ref));
m_array = root;
}
}
double operator()(BasicArray<double>& vec)
{
double ans=0.0;
for (unsigned int i=0; i<vec.size(); i++)
ans += vec[i]*vec[i];
return ans;
}
bool BasicArray<T>::compare(const BasicArray<T>& a) const
{
size_t n = size();
if (a.size() != n)
return false;
const T* data_1 = reinterpret_cast<const T*>(m_data);
const T* data_2 = reinterpret_cast<const T*>(a.m_data);
return std::equal(data_1, data_1+n, data_2);
}
BasicArray::BasicArray(const BasicArray& ba)
{
size_ = ba.size();
data_ = new double[size_];
double *pos = ba.data_;
for (int i = 0; i < size_; ++i,++pos)
{
data_[i] = *pos;
}
}
//void jj::selectionSort(BasicArray& a){
// int tmp(0);
// for ( int i = 0; i < a.size(); ++i) {
// int k = i;
// for (int j = i+1; j < a.size(); ++j){
// if ( a[j] < a[k] ){
// k = j;
// }
// }
// tmp = a[k];
// a[k] = a[i];
// a[i] = tmp;
// }
//}
void jj::selectionSort(BasicArray& a)
{
int i,j,k;
for(i=0;i<a.size();++i)
{
k=i;
for(j=i+1;j<a.size();++j)
{
if(a[j]<a[k])
k=j;
}
//swap(a[i],a[k]);
if ( i != k)
{
int tmp = a[k];
a[k] = a[i];
a[i] = tmp;
}
std::cout << a;
}
}
/*!
\brief copy constructor
\param f2 the BasicArray to copy
\author Philippe Lavoie
\date 24 January 1997
*/
template<class T> BasicArray<T>::BasicArray(const BasicArray<T>& f2)
{
rsize = sze = 0 ;
x = 0 ;
resize(f2.size());
T *p2,*p1 ;
p1 = x-1 ;
p2 = f2.x - 1 ;
for (int k = rsize; k >0; --k)
*(++p1) = *(++p2) ;
destruct = 1 ;
}
void chebexp(double (*f)(T), T a, T b, T eps,
BasicArray<T> &c, T &err)
{
int lenc = c.n() ;
int j, k, l, n;
T esf, ba, cos2, sin2, wi, ss, x, y, t, h, eref, erefh, errh;
esf = 10;
ba = T(0.5) * (b - a);
c[0] = T(0.5) * (*f)(a);
c[2] = T(0.5) * (*f)(b);
c[1] = (*f)(a + ba);
c[lenc - 1] = c[0] - c[2];
c[lenc] = c[0] + c[2] + c[1];
c[lenc - 2] = c[0] + c[2] - c[1];
cos2 = 0;
sin2 = 1;
wi = -1;
h = 1;
l = 1;
n = 2;
eref = erefh = T() ;
do {
ss = 2 * sin2;
cos2 = sqrt(2 + cos2);
sin2 /= 2 + cos2;
x = ba * sin2;
y = 0;
for (j = 0; j <= l - 1; j++) {
x += y;
y += ss * (ba - x);
c[j] = (*f)(a + x);
c[n - 1 - j] = (*f)(b - x);
}
wi /= cos2;
ddct(n, T(0.5) * cos2, wi, c);
l = n;
n *= 2;
for (j = l - 1; j >= 0; j--) {
k = lenc - j;
t = c[k] - c[j];
c[k] += c[j];
c[lenc - n + j] = t;
}
if (n == 4) {
eref = T(0.25) * (fabs(c[lenc]) + fabs(c[lenc - 1]) +
fabs(c[lenc - 2]) + fabs(c[lenc - 3]) + fabs(c[lenc - 4]));
erefh = eref * sqrt(eps);
eref *= eps;
err = erefh;
}
h *= T(0.5);
errh = esf * err;
err = h * (T(0.5) * fabs(c[lenc - n]) + fabs(c[lenc - n + 1]));
} while ((err > eref || errh > erefh) && 2 * n + 4 <= lenc);
c[lenc - n] *= T(0.5);
c[lenc] *= T(0.5);
for (j = lenc - n; j <= lenc; j++) {
c[j] *= h;
}
if (err > eref || errh > erefh) {
err = -(err);
} else {
do {
n -= 2;
err += fabs(c[lenc - n]) + fabs(c[lenc - n + 1]);
} while (err < eref && n > 2);
n += 2;
err = eref;
}
if (ba != 0) {
c[3] = 1 / ba;
} else {
c[3] = 0;
}
c[2] = T(0.5) * (b + a);
c[1] = n + T(0.5);
c[0] = lenc + T(0.5);
}
