arraytools.h

Go to the documentation of this file.

/* =====================================================================================
 
                      The UQ Toolkit (UQTk) version 3.1.5
                          Copyright (2024) NTESS
                        https://www.sandia.gov/UQToolkit/
                        https://github.com/sandialabs/UQTk
 
     Copyright 2024 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
     Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government
     retains certain rights in this software.
 
     This file is part of The UQ Toolkit (UQTk)
 
     UQTk is open source software: you can redistribute it and/or modify
     it under the terms of BSD 3-Clause License
 
     UQTk is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     BSD 3 Clause License for more details.
 
     You should have received a copy of the BSD 3 Clause License
     along with UQTk. If not, see https://choosealicense.com/licenses/bsd-3-clause/.
 
     Questions? Contact the UQTk Developers at https://github.com/sandialabs/UQTk/discussions
     Sandia National Laboratories, Livermore, CA, USA
===================================================================================== */
 
#ifndef ARRAYTOOLS_H
#define ARRAYTOOLS_H
 
#include <stdlib.h>
#include "Array1D.h"
#include "Array2D.h"
 
template <typename T> void array1Dto2D(Array1D<T>& arr_1d,Array2D<T>& arr);
 
template <typename T> void array2Dto1D(Array2D<T>& arr_2d,Array1D<T>& arr);
 
template <typename T> void paste(Array1D<T>& arr1,Array1D<T>& arr2,Array2D<T>& arr);
 
template <typename T> void generate_multigrid(Array2D<T>& multigrid,Array2D<T>& grid);
 
void paste(Array2D<double>& x, Array2D<double>& y, Array2D<double>& xy);
 
void merge(Array2D<double>& x, Array2D<double>& y, Array2D<double>& xy);
void merge(Array1D<double>& x, Array1D<double>& y, Array1D<double>& xy);
void merge(Array1D<int>&    x, Array1D<int>&    y, Array1D<int>&    xy);
 
void append(Array1D<double>& x, Array1D<double>& y);
void append(Array1D<int>&    x, Array1D<int>&    y);
 
template <typename T> void transpose(Array2D<T> &x, Array2D<T> &xt);
 
void flatten(Array2D<double>& arr_2, Array1D<double>& arr_1);
 
void fold_1dto2d_rowfirst(Array1D<double>& x1, Array2D<double>& x2);
 
void fold_1dto2d_colfirst(Array1D<double>& x1, Array2D<double>& x2);
 
void swap(Array1D<double>& arr,int i,int j);
 
void swap(Array2D<double>& arr,int i,int j);
 
double access(int nx, int ny, Array1D<double>& arr_1, int i, int j);
 
double accessPythonHelper(int nx, int ny, Array1D<double>& arr_1, int i, int j);
 
template <typename T> void getRow(Array2D<T> &arr2d, int k, Array1D<T> &arr1d);
 
template <typename T> void getCol(Array2D<T> &arr2d, int k, Array1D<T> &arr1d);
 
template <typename T> void addVal(int n, T *arr1d, T val) ;
 
template <typename T> void addVal(Array1D<T> &arr1d, T val) ;
 
template <typename T> void addVal(Array2D<T> &arr2d, T val) ;
 
template <typename T> void subVector(Array1D<T> &vector, Array1D<int> &ind, Array1D<T> &subvector);
 
template <typename T> void subMatrix_row(Array2D<T> &matrix, Array1D<int> &ind, Array2D<T> &submatrix);
 
template <typename T> void subMatrix_col(Array2D<T> &matrix, Array1D<int> &ind, Array2D<T> &submatrix);
 
template <typename T> void matPvec(Array2D<T> &matrix, const Array1D<T> &rc, T alpha, char *RC);
 
template <typename T> T maxVal(const Array1D<T>& vector, int *indx) ;
 
void setdiff(Array1D<int> &A, Array1D<int> &B, Array1D<int> &C) ;
 
void setdiff_s(Array1D<int> &A, Array1D<int> &B, Array1D<int> &C) ;
 
void shell_sort (int *a, int n) ;
void shell_sort(Array1D<int>& array);
void shell_sort(Array1D<double>& array);
void shell_sort_col(Array2D<double>& array,int col,Array1D<int>& newInd, Array1D<int>& oldInd);
void shell_sort_all(Array2D<double>& array,Array1D<int>& newInd, Array1D<int>& oldInd);
void quicksort3(Array1D<double>& arr, int l, int r);
void quicksort3(Array2D<double>& arr,int left, int right,int col);
void quicksort3(Array2D<double>& arr,int left, int right);
 
void intersect(Array1D<int> &A, Array1D<int> &B, Array1D<int> &C, Array1D<int> &iA,Array1D<int> &iB) ;
void intersect(Array1D<int> &A, Array1D<int> &B, Array1D<int> &C) ;
 
template <typename T> void find(Array1D<T> &theta, T lmbda, string type, Array1D<int> &indx) ;
 
void prodAlphaMatVec (Array2D<double>& A, Array1D<double>& x, double alpha, Array1D<double>& y) ;
void prodAlphaMatTVec(Array2D<double>& A, Array1D<double>& x, double alpha, Array1D<double>& y) ;
void prodAlphaMatMat(Array2D<double>& A, Array2D<double>& B, double alpha, Array2D<double>& C);
void prodAlphaMatTMat(Array2D<double>& A, Array2D<double>& B, double alpha, Array2D<double>& C) ;
void addVecAlphaVecPow(Array1D<double>& x, double alpha, Array1D<double>& y, int ip) ;
double prod_vecTmatvec(Array1D<double>& a, Array2D<double>& B, Array1D<double>& c);
Array2D<double> MatTMat(Array2D<double>& A) ;
 
 
template <typename T> void delRow(Array2D<T>& A, int irow) ;
 
template <typename T> void delCol(Array2D<T> &A, int icol) ;
 
template <typename T> void delCol(Array1D<T> &x, int icol) ;
 
void paddMatRow(Array2D<double>& A, Array1D<double>& x) ;
void paddMatCol(Array2D<double>& A, Array1D<double>& x) ;
void paddMatRow(Array2D<int>& A, Array1D<int>& x) ;
void paddMatCol(Array2D<int>& A, Array1D<int>& x) ;
void paddMatColScal(Array2D<double>& A, Array1D<double>& x, double scal) ;
 
bool is_equal(Array1D<int>& a, Array1D<int>& b);
bool is_equal(Array1D<double>& a, Array1D<double>& b);
bool is_less(Array1D<int>& a, Array1D<int>& b);
bool is_less(Array1D<double>& a, Array1D<double>& b);
 
int vecIsInArray(Array1D<int>& vec, Array2D<int>& array);
 
double select_kth(int k, Array1D<double>& arr);
 
double logdeterm(Array2D<double>& mat);
 
double trace(Array2D<double>& mat);
 
double evalLogMVN(Array1D<double>& x,Array1D<double>& mu,Array2D<double>& Sigma);
 
Array2D<double> diag(Array1D<double>& diagonal_array);
/**********************************************************
NEW ROUTINES - Kenny
***********************************************************/
 
Array1D<double> copy(Array1D<double>&);
 
Array2D<double> copy(Array2D<double>&);
 
Array2D<double> mtxdel(Array2D<double>&, int index, int dim);
 
Array1D<double> add(Array1D<double>&, Array1D<double>&);
 
Array2D<double> add(Array2D<double>&, Array2D<double>&);
 
void addinplace(Array2D<double>& x, Array2D<double>& y);
 
void addinplace(Array1D<double>& x, Array1D<double>& y);
 
Array1D<double> subtract(Array1D<double>&, Array1D<double>&);
 
Array2D<double> subtract(Array2D<double>&, Array2D<double>&);
 
void subtractinplace(Array2D<double>& x, Array2D<double>& y);
 
void subtractinplace(Array1D<double>& x, Array1D<double>& y);
 
Array1D<double> scale(Array1D<double>&, double);
 
Array2D<double> scale(Array2D<double>&, double);
 
void scaleinplace(Array1D<double>&, double);
 
void scaleinplace(Array1D<int>&, int);
 
void scaleinplace(Array2D<double>&, double);
 
void scaleinplace(Array2D<int>&, int);
 
Array2D<double> dotmult(Array2D<double>&A,Array2D<double>&B );
 
Array1D<double> dotmult(Array1D<double>&A,Array1D<double>&B );
 
Array2D<double> dotdivide(Array2D<double>&A,Array2D<double>&B );
 
Array1D<double> dotdivide(Array1D<double>&A,Array1D<double>&B );
 
double norm(Array1D<double>&);
 
double dist_sq(Array1D<double>& x, Array1D<double>& y, Array1D<double>& w);
 
Array2D<double> Trans(Array2D<double>&);
 
double dot(Array1D<double>&, Array1D<double>&);
 
Array1D<double> dot(Array2D<double>&, Array1D<double>&);
 
Array2D<double> dot(Array2D<double>&, Array2D<double>&);
 
Array2D<double> dotT(Array2D<double>&, Array2D<double>&);
 
Array2D<double> INV(Array2D<double> &A);
 
Array2D<double> AinvH(Array2D<double> &A,Array2D<double> &H);
 
Array1D<double> Ainvb(Array2D<double> &A,Array1D<double> &b);
 
void LSTSQ(Array2D<double> &A, Array1D<double> &b, Array1D<double> &x);
 
void QR(Array2D<double>&B,Array2D<double>&Q,Array2D<double>&R);
 
void SVD(Array2D<double>&A,Array2D<double>&U,Array1D<double>&S,Array2D<double>&VT);
 
void printarray(Array1D<double>&);
 
void printarray(Array1D<int>&);
 
void printarray(Array2D<double>&);
 
void printarray(Array2D<int>&);
 
 
//---------------------------------------------------------------------------------------
#endif // ARRAYTOOLS_H