static void CombinationWithDuplicatedElementsHelper(Array1D &array, int left, int k,
int times, Array1D &temp, Array2D &result)
{
assert(left >= 0);
if (array.size() - left < k) { return; }
if (k == 0) {
result.push_back(temp);
return;
}
if (left == 0 || array[left] != array[left - 1]) {
temp.push_back(array[left]);
CombinationWithDuplicatedElementsHelper(array, left + 1, k - 1, 1, temp, result);
temp.pop_back();
CombinationWithDuplicatedElementsHelper(array, left + 1, k, 1, temp, result);
}
else {
if (temp.size() >= times && temp[temp.size() - times] == array[left]) {
temp.push_back(array[left]);
CombinationWithDuplicatedElementsHelper(array, left + 1, k - 1, times + 1, temp, result);
temp.pop_back();
}
CombinationWithDuplicatedElementsHelper(array, left + 1, k, times + 1, temp, result);
}
}
BayesNetwork::BayesNetwork(Array1D<Discretizer*> &discretizers)
: parentIndex(discretizers.size()),
probTables(discretizers.size()),
discretizers(discretizers)
{
parentIndex.setAllTo(-1);
}
vector<Mat> SegmentDataByIDX(const Mat& data, const Mat& idx)
{
assert(data.type() == CV_32F || data.type() == CV_64F);
assert(data.rows > 0 && data.cols > 0 && idx.rows > 0 && idx.cols > 0);
assert(data.cols == idx.cols);
Array2D idx_hash;
if (idx.type() != CV_32S) {
Mat idx_tmp = idx;
Mat_<int> tmp;
idx_tmp.convertTo(tmp, CV_32S);
idx_hash = ComputeIDX(tmp);
} else{
idx_hash = ComputeIDX(idx);
}
if (idx_hash.empty()) { return vector<Mat>(); }
vector<Mat> result(idx_hash.size());
for (int i = 0; i < idx_hash.size(); i++) {
Array1D cur = idx_hash[i];
if (cur.empty()) { return vector<Mat>(); }
Mat temp(data.rows, cur.size(), data.type());
Mat col(data.rows, 1, data.type());
for (int j = 0; j < cur.size(); j++) {
col = temp(Range(0, data.rows), Range(j, j + 1));
data(Range(0, data.rows), Range(cur[j] - 1, cur[j])).copyTo(col);
}
result[i] = temp;
}
return result;
}
static void CombinationWithDuplicatedElementsVer2Helper(Array1D &array, int left,
int k, int times,
Array1D &temp,
Array2D &result)
{
if (array.size() - left < k) { return; }
if (k == 0) {
result.push_back(temp);
return;
}
for (int i = left; i <= array.size(); i++) {
if (i == 0 || array[i] != array[i - 1]) {
times = 1;
temp.push_back(array[i]);
CombinationWithDuplicatedElementsVer2Helper(array, i + 1, k - 1, 1, temp, result);
temp.pop_back();
}
else {
times++;
if (temp.size() >= times - 1 && temp[temp.size() - times + 1] == array[i]) {
temp.push_back(array[i]);
CombinationWithDuplicatedElementsVer2Helper(array, i + 1, k - 1, times, temp, result);
temp.pop_back();
}
}
}
}
Array2D CombinationWithDuplicatedElementsByNonRecursion(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
std::sort(array.begin(), array.end());
result.push_back(Array1D());
int last = array[0], opt_result_num = 1;
for (int i = 0; i < array.size(); i++) {
if (array[i] != last) {
last = array[i];
opt_result_num = result.size();
}
Array2D::size_type result_size = result.size();
for (int j = result_size - 1; j >= result_size - opt_result_num; j--) {
result.push_back(result[j]);
result.back().push_back(array[i]);
}
}
return result;
}
Array1D<T> zero_pad(const Array1D<T>& v, int n)
{
it_assert(n>=v.size(), "zero_pad() cannot shrink the vector!");
Array1D<T> v2(n);
v2.set_subvector(0, v.size()-1, v);
if (n > v.size())
v2.set_subvector(v.size(), n-1, T(0));
return v2;
}
Array2D CombinationVer2(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp;
CombinationVer2Helper(array, 0, array.size() - 1, K, temp, result);
}
Array2D CombinationByDecrease(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp(K);
CombinationByDecreaseHelper(array, array.size(), K, temp, result);
}
Array2D Combination(Array1D array, int K) {
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array);
return result;
}
Array1D temp;
CombinationHelper(array, 0, array.size() - 1, K, temp, result);
return result;
}
void
CDFBasis<d,dt>::evaluate
(const unsigned int derivative,
const RIndex& lambda,
const Array1D<double>& points, Array1D<double>& values)
{
values.resize(points.size());
for (unsigned int i(0); i < values.size(); i++) {
values[i] = evaluate(derivative, lambda, points[i]);
}
}
static void PermutationHelper(Array1D &array, int index, Array2D &result)
{
if (index == array.size()) {
result.push_back(array);
return;
}
for (int i = index; i < array.size(); ++i) {
std::swap(array[index], array[i]);
PermutationHelper(array, index + 1, result);
std::swap(array[index], array[i]);
}
}
Array1D<T> cross(const Array1D<T>& v1, const Array1D<T>& v2)
{
it_assert( v1.size() == 3 && v2.size() == 3, "cross: vectors should be of size 3");
Array1D<T> r(3);
r(0) = v1(1) * v2(2) - v1(2) * v2(1);
r(1) = v1(2) * v2(0) - v1(0) * v2(2);
r(2) = v1(0) * v2(1) - v1(1) * v2(0);
return r;
}
static void PermutationUniqueHelper(Array1D &array, int index, Array2D &result)
{
if (index == array.size()) {
result.push_back(array);
return;
}
for (int i = index; i < array.size(); i++) {
if (HasSameElement(array, index, i, array[i])) {
std::swap(array[index], array[i]);
PermutationUniqueHelper(array, index + 1, result);
std::swap(array[index], array[i]);
}
}
}
int AlignmentBuilder::getAlignmentLength(
Array1D<Poset<ResidueAddress>::Vertex<ResidueAddress>*> &roots)
{
int n=roots.size(), r=0;
for(int i=0 ; i<n ; ++i)
if(roots[i]->getData().hasLeafDescendents() || wantOrphans) ++r;
return r;
}
static PyObject* py_glDrawBuffers(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Array1D<Enum> buffers;
if (buffers.fromPy(PyTuple_GetItem(args, 0))) {
glDrawBuffers(buffers.size(), buffers);
}
Py_RETURN_NONE;
}
static PyObject* py_glShaderSource(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 2);
Uint shader(PyTuple_GetItem(args, 0));
Array1D<String> strings;
if (strings.fromPy(PyTuple_GetItem(args, 1))) {
glShaderSource(shader, strings.size(), strings, 0);
}
Py_RETURN_NONE;
}
void Application::write(Array1D<double> &array,File &os,ostream &textStream)
{
int L=array.size();
os<<L;
if(wantText) textStream<<L<<endl;
for(int i=0 ; i<L ; ++i) {
os<<array[i];
if(wantText) textStream<<array[i]<<endl;
}
}
Array2D CombinationWithDuplicatedElementsVer2(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D temp;
}
const Array2D inverse_quantise_transform_np(const Array2D& qCoeffs,
const Array2D& qIndices,
const Array1D& qMatrix) {
// TO DO: Check numberOfSubbands=3n+1 ?
BlockVector aQIndices(qMatrix.ranges());
const int numberOfSubbands = qMatrix.size();
for (char band=0; band<numberOfSubbands; ++band) {
aQIndices[band] = adjust_quant_indices(qIndices, qMatrix[band]);
}
return inverse_quantise_subbands_np(qCoeffs, aQIndices);
}
/**
* @brief find all permutation of array
* @brief array has some repeating elements
*/
Array2D PermutationUnique(Array1D array)
{
Array2D result;
if (array.empty()) { return result; }
if (array.size() == 1) {
result.push_back(array);
return result;
}
PermutationUniqueHelper(array, 0, result);
return result;
}
const Array2D inverse_quantise_transform_np(const Array2D& qCoeffs,
const int qIndex,
const Array1D& qMatrix) {
// TO DO: Check numberOfSubbands=3n+1 ?
const int numberOfSubbands = qMatrix.size();
const int waveletDepth = (numberOfSubbands-1)/3;
BlockVector subbands = split_into_subbands(qCoeffs, waveletDepth);
for (int band=0; band<numberOfSubbands; ++band) {
const int aQIndex = adjust_quant_index(qIndex, qMatrix[band]);
subbands[band] = inverse_quantise_block(subbands[band], aQIndex);
}
return merge_subbands(subbands);
}
double Application::recompute(double t)
{
SubstitutionMatrix &M=*Q->instantiate(t);
Array1D<double> eq;
M.getEqFreqs(eq);
int n=eq.size();
double r=0.0;
for(BOOM::Symbol s=0 ; s<n ; ++s) {
r+=eq[s]*M(s,s);
}
delete &M;
return r;
}
Array2D CombinationByNonRecursion(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
Array1D cur(1);
for (int i = 1; i <= array.size(); i++) {
Array1D::size_type size = cur.size();
Array1D temp;
/** @bug has some problems */
for (int j = 0; j < size; j++) {
temp.push_back(cur[j]);
temp.push_back(array[i]);
if (temp.size() == K) { result.push_back(temp); }
else { cur.push_back(array[i]); }
}
}
return result;
}
Array2D CombinationByBinary(Array1D array, int K)
{
Array2D result;
if (array.empty() || K <= 0) { return result; }
if (array.size() < K) {
result.push_back(array); /** @warning maybe exclude it */
return result;
}
/** @warning sort or not */
Array1D temp;
int begin = (1 << K) - 1, end = (1 << array.size()) - (1 << (array.size() - K));
for (int bit = begin; bit <= end; bit = NextBit(bit)) {
temp.clear();
for (int i = 0; i < array.size(); i++) {
if (bit & (1 << i)) {
temp.push_back(array[i]);
}
}
result.push_back(temp);
}
return result;
}
static void CombinationByIncreaseHelper(Array1D &array, int left, int count,
Array1D &temp, Array2D &result)
{
for (int i = left; i < array.size() + 1 - count; i++) {
temp[count - 1] = array[i];
if (count - 1 == 0) {
result.push_back(temp);
}
else {
CombinationByIncreaseHelper(array, i + 1, count - 1, temp, result);
}
}
}
bool NextPermutation(Array1D &array)
{
Array1D::size_type size = array.size();
if (size <= 1) { return false; }
for (int i = size - 2, ii = size - 1; i >= 0; i--, ii--) {
if (array[i] < array[ii]) {
int j = size - 1;
while (array[j] <= array[i]) { j--; }
std::swap(array[i], array[j]);
std::reverse(array.begin() + ii, array.end());
return true;
}
}
std::reverse(array.begin(), array.end());
return false;
}
void gramSchmidtProcess(Array1D<V>& vectors)
{
V* vtmp;
unsigned int i, n;
for (n = 0; n < vectors.size(); n++) {
// orthogonalize the n-th vector respective to the previous ones
for (i = 0; i < n; i++) {
vtmp = new V(vectors[i]);
vtmp->scale(-vectors[i].inner_product(vectors[n]));
vectors[n].add(*vtmp);
delete vtmp;
vtmp = NULL;
}
// norm the n-th vector
vectors[n].scale(1/sqrt(vectors[n].inner_product(vectors[n])));
}
}
Array1D<T> zero_pad(const Array1D<T>& v)
{
int n = pow2(needed_bits(v.size()));
return n==v.size() ? v : zero_pad(v, n);
}
void sort(Array1D<T>& data)
{
QS(0,data.size()-1,data);
}
