1 /******************************************************************************
2 * Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
3 * HYPRE Project Developers. See the top-level COPYRIGHT file for details.
4 *
5 * SPDX-License-Identifier: (Apache-2.0 OR MIT)
6 ******************************************************************************/
7
8 /******************************************************************************
9 *
10 * tests for various function in this directory
11 *
12 *****************************************************************************/
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include "mli_utils.h"
17
18 extern int mli_computespectrum_(int *,int *,double *, double *, int *,
19 double *, double *, double *, int *);
20 void testEigen();
21 void testMergeSort();
22
23 /******************************************************************************
24 * main program
25 *****************************************************************************/
26
main()27 main()
28 {
29 int test=2;
30
31 switch (test)
32 {
33 case 1 : testEigen();
34 case 2 : testMergeSort();
35 }
36 }
37
38 /******************************************************************************
39 * test the Fortan functin for computing eigenvalues
40 *---------------------------------------------------------------------------*/
41
testEigen()42 void testEigen()
43 {
44 int i, mDim=24, ierr, matz=0;
45 double *matrix, *evalues, *evectors, *daux1, *daux2;
46 FILE *fp;
47
48 matrix = hypre_TAlloc(double, mDim * mDim , HYPRE_MEMORY_HOST);
49 fp = fopen("test.m", "r");
50 if ( fp == NULL )
51 {
52 printf("testEigen ERROR : file not found.\n");
53 exit(1);
54 }
55 for ( i = 0; i < mDim*mDim; i++ ) fscanf(fp, "%lg", &(matrix[i]));
56 evectors = hypre_TAlloc(double, mDim * mDim , HYPRE_MEMORY_HOST);
57 evalues = hypre_TAlloc(double, mDim , HYPRE_MEMORY_HOST);
58 daux1 = hypre_TAlloc(double, mDim , HYPRE_MEMORY_HOST);
59 daux2 = hypre_TAlloc(double, mDim , HYPRE_MEMORY_HOST);
60 mli_computespectrum_(&mDim, &mDim, matrix, evalues, &matz, evectors,
61 daux1, daux2, &ierr);
62 for ( i = 0; i < mDim; i++ ) printf("eigenvalue = %e\n", evalues[i]);
63 hypre_TFree(matrix, HYPRE_MEMORY_HOST);
64 hypre_TFree(evectors, HYPRE_MEMORY_HOST);
65 hypre_TFree(evalues, HYPRE_MEMORY_HOST);
66 hypre_TFree(daux1, HYPRE_MEMORY_HOST);
67 hypre_TFree(daux2, HYPRE_MEMORY_HOST);
68 }
69
70 /******************************************************************************
71 * test merge sort utility
72 *---------------------------------------------------------------------------*/
73
testMergeSort()74 void testMergeSort()
75 {
76 int i, j, nlist=7, maxLeng=20, **list, **list2, *listLengs;
77 int newNList, *newList, *checkList, checkN, checkFlag;
78
79 listLengs = hypre_TAlloc(int, nlist , HYPRE_MEMORY_HOST);
80 list = hypre_TAlloc(int*, nlist , HYPRE_MEMORY_HOST);
81 list2 = hypre_TAlloc(int*, nlist , HYPRE_MEMORY_HOST);
82 for ( i = 0; i < nlist; i++ )
83 {
84 list[i] = hypre_TAlloc(int, maxLeng , HYPRE_MEMORY_HOST);
85 list2[i] = hypre_TAlloc(int, maxLeng , HYPRE_MEMORY_HOST);
86 }
87 listLengs[0] = 5;
88 list[0][0] = 4;
89 list[0][1] = 5;
90 list[0][2] = 6;
91 list[0][3] = 8;
92 list[0][4] = 9;
93 listLengs[1] = 1;
94 list[1][0] = 10;
95 listLengs[2] = 4;
96 list[2][0] = 5;
97 list[2][1] = 6;
98 list[2][2] = 7;
99 list[2][3] = 9;
100 listLengs[3] = 2;
101 list[3][0] = 10;
102 list[3][1] = 11;
103 listLengs[4] = 3;
104 list[4][0] = 6;
105 list[4][1] = 7;
106 list[4][2] = 8;
107 listLengs[5] = 3;
108 list[5][0] = 10;
109 list[5][1] = 11;
110 list[5][2] = 12;
111 listLengs[6] = 3;
112 list[6][0] = 7;
113 list[6][1] = 8;
114 list[6][2] = 9;
115 checkN = 0;
116 for ( i = 0; i < nlist; i++ )
117 for ( j = 0; j < listLengs[i]; j++ ) list2[i][j] = checkN++;
118
119 for ( i = 0; i < nlist; i++ )
120 MLI_Utils_IntQSort2(list[i], NULL, 0, listLengs[i]-1);
121 for ( i = 0; i < nlist; i++ )
122 for ( j = 0; j < listLengs[i]; j++ )
123 printf("original %5d %5d = %d\n", i, j, list[i][j]);
124 printf("MergeSort begins...\n");
125 MLI_Utils_IntMergeSort(nlist, listLengs, list, list2, &newNList, &newList);
126 for ( i = 0; i < newNList; i++ )
127 printf("after %5d = %d\n", i, newList[i]);
128 printf("MergeSort ends.\n");
129 /*
130 for ( i = 0; i < newNList; i++ )
131 printf("Merge List %5d = %d\n", i, newList[i]);
132 checkList = hypre_TAlloc(int, nlist * maxLeng , HYPRE_MEMORY_HOST);
133 for ( i = 0; i < nlist; i++ )
134 for ( j = 0; j < maxLeng; j++ ) checkList[i*maxLeng+j] = list[i][j];
135 printf("QSort begins...\n");
136 MLI_Utils_IntQSort2(checkList, NULL, 0, nlist*maxLeng-1);
137 printf("QSort ends.\n");
138 checkN = 1;
139 for ( i = 1; i < nlist*maxLeng; i++ )
140 if ( checkList[checkN-1] != checkList[i] )
141 checkList[checkN++] = checkList[i];
142 if ( checkN != newNList )
143 printf("MergeSort and QSort lengths = %d %d\n", newNList, checkN);
144 checkFlag = 0;
145 for ( i = 0; i < newNList; i++ )
146 {
147 if ( checkList[i] != newList[i] )
148 {
149 printf("MergeSort and QSort discrepancy %5d = %5d %5d\n", i,
150 newList[i], checkList[i]);
151 checkFlag++;
152 }
153 }
154 printf("MergeSort and QSort lengths = %d %d\n", newNList, checkN);
155 if ( checkFlag == 0 )
156 printf("MergeSort and QSort gives same result.\n");
157
158 for ( i = 0; i < nlist; i++ )
159 {
160 hypre_TFree(list[i], HYPRE_MEMORY_HOST);
161 hypre_TFree(list2[i], HYPRE_MEMORY_HOST);
162 }
163 hypre_TFree(checkList , HYPRE_MEMORY_HOST);
164 */
165 hypre_TFree(listLengs, HYPRE_MEMORY_HOST);
166 hypre_TFree(list, HYPRE_MEMORY_HOST);
167 hypre_TFree(list2, HYPRE_MEMORY_HOST);
168 hypre_TFree(newList, HYPRE_MEMORY_HOST);
169 }
170
171