//TransformedDomainRecursiveFilter_Horizontal
void TDRF_H(float** channel, float** derivatives, float sigma, int h, int w){
float a = expf(-sqrtf(2)/sigma);
//V
float** V = createArray(h,w);
for (int row = 0; row < h; row++) {
for (int col = 0; col < w; col++) {
V[row][col] = powf(a,derivatives[row][col]);
}
}
//LEFT->RIGHT FILTER
for (int row = 0; row < h; row++) {
for (int col = 1; col < w; col++) {
channel[row][col] = channel[row][col] + V[row][col]*(channel[row][col - 1] - channel[row][col]);
}
}
//RIGHT->LEFT FILTER
for (int row = 0; row < h; row++) {
for (int col = w-2; col >= 0; col--) {
channel[row][col] = channel[row][col] + V[row][col+1]*(channel[row][col + 1] - channel[row][col]);
}
}
destroyArray(V);
}
int main(int argc, char** argv){
char* path = NULL;
char buffer[MAXSIZE] = {0};
int fullOffset = 0;
int lineNumber = 0;
char str1[MAXSEQUENCE] = {0};
char str2[MAXSEQUENCE] = {0};
struct NWArray myarray;
if(argc > 2){
printf("Error too many arguments\n");
return 1;
}else if(argc == 2){
path = argv[1];
printf("Text file is : %s \n", path);
printf("\n");
}else if(argc < 2){
printf("Error not enough arguments, path of text file is missing\n");
return 1;
}
int sizeRead = 0;
do{
// Acquisition of one line of "path" file in a buffer
if((sizeRead = readLine(path, fullOffset, buffer, MAXSIZE) ) < 1){
printf("This is the end of our program\n");
break;
}
printf("Iteration : %d\nAcquired line is : %s\n", ++lineNumber, buffer);
// Separation of this buffer (according to " | ") in two strings
parseLine(buffer, sizeRead, str1, str2, MAXSEQUENCE);
fullOffset += sizeRead;
printf("\t str1= %s", str1);
printf("\t str2= %s\n", str2);
// Needleman Wunsh algorithm
initArray(&myarray, strlen(str1)+1, strlen(str2)+1);
NWAlgo(&myarray, str1, str2);
printNW(&myarray);
printf("The maximum combinaison that can be obtained is : ");
printf("%d\n", cell_value(getCellXY(&myarray, strlen(str1), strlen(str2))));
printf("\n");
printf("-----------------------------------------------------------\n");
printf("\n");
destroyArray(&myarray);
}while(sizeRead != 0);
return 0;
}
static void FreeUserData(WebData wdata)
{
int i, ngrp;
ngrp = wdata->ngrp;
for(i=0; i < ngrp; i++) {
destroyMat((wdata->P)[i]);
destroyArray((wdata->pivot)[i]);
}
N_VDestroy_Serial(wdata->rewt);
free(wdata);
}
/* Free user data memory */
static void FreeUserData(UserData data)
{
int lx, ly;
for (lx = 0; lx < MXSUB; lx++) {
for (ly = 0; ly < MYSUB; ly++) {
destroyMat((data->P)[lx][ly]);
destroyMat((data->Jbd)[lx][ly]);
destroyArray((data->pivot)[lx][ly]);
}
}
free(data);
}
static void FreeUserData(UserData data)
{
int jx, jy;
for (jx=0; jx < MX; jx++) {
for (jy=0; jy < MY; jy++) {
destroyMat((data->P)[jx][jy]);
destroyMat((data->Jbd)[jx][jy]);
destroyArray((data->pivot)[jx][jy]);
}
}
free(data);
}
static void FreeUserData(UserData data)
{
int jx, jz;
for (jx=0; jx < MX; jx++) {
for (jz=0; jz < MZ; jz++) {
destroyMat((data->P)[jx][jz]);
destroyMat((data->Jbd)[jx][jz]);
destroyArray((data->pivot)[jx][jz]);
}
}
free(data->p);
free(data);
}
static void FreeUserData(UserData webdata)
{
int ix, jy;
for (ix = 0; ix < MXSUB; ix++) {
for (jy = 0; jy < MYSUB; jy++) {
destroyMat((webdata->PP)[ix][jy]);
destroyArray((webdata->pivot)[ix][jy]);
}
}
destroyMat(webdata->acoef);
N_VDestroy_Parallel(webdata->rates);
N_VDestroy_Parallel(webdata->ewt);
free(webdata);
}
static void FreeUserData(UserData data)
{
int jx, jy;
for (jx=0; jx < MX; jx++) {
for (jy=0; jy < MY; jy++) {
destroyMat((data->P)[jx][jy]);
destroyArray((data->pivot)[jx][jy]);
}
}
destroyMat(acoef);
free(bcoef);
free(cox);
free(coy);
N_VDestroy_Serial(data->rates);
free(data);
}
void main(){
//三维数组定义
float dim_arr[2][3][2] = { { {5,12}, {1,5}, {7,9} }, { {2,9},{3,8},{15,25} } };
int b,h,f;
//输出三维数组
printf("Printf the three array:\n");
for(b=0;b<2;b++){
printf("The %d dim is:\n",b+1);
for(h=0;h<3;h++){
printf(" The %d dim is:\n",h+1);
for(f=0;f<2;f++){
printf("%6.1f ",dim_arr[b][h][f]);
}
printf("\n");
}
printf("\n");
}
//二维数组定义
Array Arr;
Array *A = &Arr;
int i,j,k,*p,dim=3,bound1=3,bound2=4,bound3=2;//a[3][4][2]数组
elemType e,*p1;
initArray(A,dim,bound1,bound2,bound3);//构造3*4*2的3三维数组A
//顺序输出A->bounds维数
p = A->bounds;
printf("A->bounds=");
for(i=0;i<dim;i++){
printf("%3d ",*(p+i));
}
//顺序输出A->constants
p = A->constants;
printf("\nA->constants=");
for(i=0;i<dim;i++){
printf("%3d ",*(p+i));
}
printf("\n%d page %d row %d column in array list as the following:\n",bound1,bound2,bound3);
for(i=0;i<bound1;i++){
for(j=0;j<bound2;j++){
for(k=0;k<bound3;k++){
//将i*100+j*10+k赋值给A[i][j][k]
assign(A,i*100+j*10+k,i,j,k);
value(A,&e,i,j,k);//将A[i][j][k]的值赋给e
printf("A[%d][%d][%d]=%2d ",i,j,k,e);//输出A[i][j][k]
}
printf("\n");
}
printf("\n");
}
p1 = A->base;
printf("\nA->base=\n");
//顺序输出A->base
for(i=0;i<bound1*bound2*bound3;i++){
printf("%4d ",*(p1+i));
if((i+1)%(bound2*bound3)==0) printf("\n");
}
//!(0+1)%(bound2*bound3) equal to 0;
if(destroyArray(A)) printf("\nsuccess to destroy array!");
}
/*
* -----------------------------------------------------------------------------
* Main
* -----------------------------------------------------------------------------
*/
int32_t main(int32_t aArgc, char *aArgv[])
{
perfContext sContext;
struct timeval sStart, sEnd;
int32_t sSeconds, sUseconds;
uint32_t *sArray;
/*
* Init
*/
perfContextInit(&sContext);
processArg(aArgc, aArgv, &sContext);
/*
* Allocate memory and load data
*/
(void)fprintf(stderr, "Reading data...\n");
createAndFillArray(&sContext);
sArray = sContext.mArrayToSort;
/*
* Sort it!
*/
(void)fprintf(stderr, "Start sorting...\n");
(void)gettimeofday(&sStart, NULL);
(*sContext.mSortFunc)(sArray, sContext.mCount, sizeof(uint32_t), compareFunc);
(void)gettimeofday(&sEnd, NULL);
(void)fprintf(stderr, "Completed sorting.\n");
/*
* Calculate time
*/
sSeconds = sEnd.tv_sec - sStart.tv_sec;
sUseconds = sEnd.tv_usec - sStart.tv_usec;
if (sUseconds < 0)
{
sSeconds--;
sUseconds += 1000000;
}
(void)fprintf(stderr, "\nIt took %d.%06d seconds to sort %d elements.\n\n",
sSeconds, sUseconds, sContext.mCount);
/*
* Verify if option is set
*/
if (sContext.mDoVerify == 1)
{
(void)fprintf(stderr, "Checking if resulting array is correctly sorted...... ");
if (verifyArrayIsSorted(sArray, sContext.mCount) == 0)
{
(void)fprintf(stderr, "OK\n");
}
else
{
(void)fprintf(stderr, "FAIL\n");
}
}
/*
* Free memory
*/
destroyArray(sArray);
return 0;
}
int main(int argc, char** argv) {
float** testRedChannel = generateImageArray("red.txt");
float** testGreenChannel = generateImageArray("green.txt");
float** testBlueChannel = generateImageArray("blue.txt");
int h = getImageWidth("red.txt");
int w = getImageHeight("red.txt");
printf("%i rows x %i columns\n", h, w);
///////////////////////////////////////////////////////////
//////Compute the l1-norm distance of neighbor pixels./////
///////////////////////////////////////////////////////////
float** dIcdxRed = diffH(testRedChannel, h,w);
float** dIcdxGreen = diffH(testGreenChannel, h,w);
float** dIcdxBlue = diffH(testBlueChannel, h,w);
float** dIcdx = addChannels(dIcdxRed, dIcdxGreen, dIcdxBlue, h,w);
destroyArray(dIcdxRed);
destroyArray(dIcdxGreen);
destroyArray(dIcdxBlue);
float** dIcdyRed = diffV(testRedChannel, h,w);
float** dIcdyGreen = diffV(testGreenChannel, h,w);
float** dIcdyBlue = diffV(testBlueChannel, h,w);
float** dIcdy = addChannels(dIcdyRed, dIcdyGreen, dIcdyBlue, h,w);
destroyArray(dIcdyRed);
destroyArray(dIcdyGreen);
destroyArray(dIcdyBlue);
///////////////////////////////////////////////////////////
///////Compute the derivatives of the horizontal///////////
///////and vertical domain transforms./////////////////////
///////////////////////////////////////////////////////////
float factor = sigma_s / sigma_r;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
dIcdx[i][j] = 1 + factor * dIcdx[i][j];
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
dIcdy[i][j] = 1 + factor * dIcdy[i][j];
}
}
///The vertical pass is performed using a transposed image.
float** dHdyT = transpose(dIcdy, h, w);
destroyArray(dIcdy);
///////////////////////////////////////////////////////////
///////////////////Perform the filtering.//////////////////
///////////////////////////////////////////////////////////
filtering(testRedChannel, dIcdx, dHdyT, h, w, 10);
filtering(testGreenChannel, dIcdx, dHdyT, h, w, 10);
filtering(testBlueChannel, dIcdx, dHdyT, h, w, 10);
///////////////////////////////////////////////////////////
///////////////////GENERATE OUTPUT IMAGE///////////////////
///////////////////////////////////////////////////////////
generateImageFile(testRedChannel, "outred.txt", h, w);
generateImageFile(testGreenChannel, "outgreen.txt", h, w);
generateImageFile(testBlueChannel, "outblue.txt", h, w);
///////////////////////////////////////////////////////////
///////////////////////FREE MEMORY/////////////////////////
///////////////////////////////////////////////////////////
destroyArray(dIcdx);
destroyArray(dHdyT);
destroyArray(testRedChannel);
destroyArray(testGreenChannel);
destroyArray(testBlueChannel);
return 0;
}
int main()
{
void *mem;
UserData webdata;
N_Vector cc, cp, id;
int iout, jx, jy, flag;
long int maxl;
realtype rtol, atol, t0, tout, tret;
mem = NULL;
webdata = NULL;
cc = cp = id = NULL;
/* Allocate and initialize user data block webdata. */
webdata = (UserData) malloc(sizeof *webdata);
webdata->rates = N_VNew_Serial(NEQ);
webdata->acoef = newDenseMat(NUM_SPECIES, NUM_SPECIES);
webdata->ewt = N_VNew_Serial(NEQ);
for (jx = 0; jx < MX; jx++) {
for (jy = 0; jy < MY; jy++) {
(webdata->pivot)[jx][jy] = newLintArray(NUM_SPECIES);
(webdata->PP)[jx][jy] = newDenseMat(NUM_SPECIES, NUM_SPECIES);
}
}
InitUserData(webdata);
/* Allocate N-vectors and initialize cc, cp, and id. */
cc = N_VNew_Serial(NEQ);
if(check_flag((void *)cc, "N_VNew_Serial", 0)) return(1);
cp = N_VNew_Serial(NEQ);
if(check_flag((void *)cp, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ);
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
SetInitialProfiles(cc, cp, id, webdata);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize IDA. */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
flag = IDASetUserData(mem, webdata);
if(check_flag(&flag, "IDASetUserData", 1)) return(1);
flag = IDASetId(mem, id);
if(check_flag(&flag, "IDASetId", 1)) return(1);
flag = IDAInit(mem, resweb, t0, cc, cp);
if(check_flag(&flag, "IDAInit", 1)) return(1);
flag = IDASStolerances(mem, rtol, atol);
if(check_flag(&flag, "IDASStolerances", 1)) return(1);
webdata->ida_mem = mem;
/* Call IDASpgmr to specify the IDA linear solver. */
maxl = 16; /* max dimension of the Krylov subspace */
flag = IDASpgmr(mem, maxl);
if(check_flag(&flag, "IDASpgmr", 1)) return(1);
flag = IDASpilsSetPreconditioner(mem, Precond, PSolve);
if(check_flag(&flag, "IDASpilsSetPreconditioner", 1)) return(1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
flag = IDACalcIC(mem, IDA_YA_YDP_INIT, tout);
if(check_flag(&flag, "IDACalcIC", 1)) return(1);
/* Print heading, basic parameters, and initial values. */
PrintHeader(maxl, rtol, atol);
PrintOutput(mem, cc, ZERO);
/* Loop over iout, call IDASolve (normal mode), print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
flag = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL);
if(check_flag(&flag, "IDASolve", 1)) return(flag);
PrintOutput(mem, cc, tret);
if (iout < 3) tout *= TMULT; else tout += TADD;
}
/* Print final statistics and free memory. */
PrintFinalStats(mem);
/* Free memory */
IDAFree(&mem);
N_VDestroy_Serial(cc);
N_VDestroy_Serial(cp);
N_VDestroy_Serial(id);
destroyMat(webdata->acoef);
N_VDestroy_Serial(webdata->rates);
N_VDestroy_Serial(webdata->ewt);
for (jx = 0; jx < MX; jx++) {
for (jy = 0; jy < MY; jy ++) {
destroyArray((webdata->pivot)[jx][jy]);
destroyMat((webdata->PP)[jx][jy]);
}
}
free(webdata);
return(0);
}
