Actual source code: ex40.c

  1: static char help[] = "Test PETSc integer hash map.\n\n";

  3: #include <petsc/private/hashmapi.h>
  4: #include <petsc/private/hashmapiv.h>
  5: #include <petscsys.h>

  7: /* Unused, keep it for testing purposes */
  8: PETSC_HASH_MAP(HMapIP, PetscInt, void *, PetscHashInt, PetscHashEqual, NULL)

 10: /* Unused, keep it for testing purposes */
 11: typedef struct {
 12:   double x;
 13:   double y;
 14:   double z;
 15: } Point;
 16: static Point origin = {0.0, 0.0, 0.0};
 17: PETSC_HASH_MAP(HMapIS, PetscInt, Point, PetscHashInt, PetscHashEqual, origin)


 21: int main(int argc, char **argv)
 22: {
 23:   PetscHMapI   ht = NULL, hd;
 24:   PetscHMapIV  htv;
 25:   PetscInt     n, v, koff, keys[4], voff, vals[4], na, nb, i, size, *karray, off;
 26:   PetscScalar *varray, *vwork;
 27:   PetscBool    has, flag;

 30:   PetscInitialize(&argc, &argv, NULL, help);

 32:   PetscHMapICreate(&ht);
 33:   PetscTestCheck(ht != NULL);
 34:   PetscHMapIGetSize(ht, &n);
 35:   PetscTestCheck(n == 0);

 37:   PetscHMapIResize(ht, 0);
 38:   PetscHMapIGetSize(ht, &n);
 39:   PetscTestCheck(n == 0);

 41:   PetscHMapIHas(ht, 123, &has);
 42:   PetscTestCheck(has == PETSC_FALSE);
 43:   PetscHMapIGet(ht, 123, &v);
 44:   PetscTestCheck(v == -1);

 46:   PetscHMapISet(ht, 123, 42);
 47:   PetscHMapIGetSize(ht, &n);
 48:   PetscTestCheck(n == 1);
 49:   PetscHMapIHas(ht, 123, &has);
 50:   PetscTestCheck(has == PETSC_TRUE);
 51:   PetscHMapIGet(ht, 123, &v);
 52:   PetscTestCheck(v == 42);

 54:   PetscHMapIDel(ht, 123);
 55:   PetscHMapIGetSize(ht, &n);
 56:   PetscTestCheck(n == 0);
 57:   PetscHMapIHas(ht, 123, &has);
 58:   PetscTestCheck(has == PETSC_FALSE);
 59:   PetscHMapIGet(ht, 123, &v);
 60:   PetscTestCheck(v == -1);

 62:   PetscHMapIQuerySet(ht, 123, 1, &flag);
 63:   PetscTestCheck(flag == PETSC_TRUE);
 64:   PetscHMapIQuerySet(ht, 123, 1, &flag);
 65:   PetscTestCheck(flag == PETSC_FALSE);
 66:   PetscHMapIQueryDel(ht, 123, &flag);
 67:   PetscTestCheck(flag == PETSC_TRUE);
 68:   PetscHMapIQueryDel(ht, 123, &flag);
 69:   PetscTestCheck(flag == PETSC_FALSE);

 71:   PetscHMapIResize(ht, 13);
 72:   PetscHMapIGetSize(ht, &n);
 73:   PetscTestCheck(n == 0);

 75:   PetscHMapIClear(ht);
 76:   PetscHMapIGetSize(ht, &n);
 77:   PetscTestCheck(n == 0);

 79:   PetscHMapISet(ht, 321, 24);
 80:   PetscHMapISet(ht, 123, 42);
 81:   PetscHMapIGetSize(ht, &n);
 82:   PetscTestCheck(n == 2);

 84:   koff    = 0;
 85:   keys[0] = keys[1] = 0;
 86:   PetscHMapIGetKeys(ht, &koff, keys);
 87:   PetscSortInt(koff, keys);
 88:   PetscTestCheck(koff == 2);
 89:   PetscTestCheck(keys[0] == 123);
 90:   PetscTestCheck(keys[1] == 321);

 92:   voff    = 0;
 93:   vals[0] = vals[1] = 0;
 94:   PetscHMapIGetVals(ht, &voff, vals);
 95:   PetscSortInt(voff, vals);
 96:   PetscTestCheck(voff == 2);
 97:   PetscTestCheck(vals[0] == 24);
 98:   PetscTestCheck(vals[1] == 42);

100:   koff    = 0;
101:   keys[0] = keys[1] = 0;
102:   voff              = 0;
103:   vals[0] = vals[1] = 0;
104:   PetscHMapIDuplicate(ht, &hd);
105:   PetscHMapIGetKeys(ht, &koff, keys);
106:   PetscHMapIGetVals(ht, &voff, vals);
107:   PetscSortInt(koff, keys);
108:   PetscSortInt(voff, vals);
109:   PetscTestCheck(koff == 2);
110:   PetscTestCheck(voff == 2);
111:   PetscTestCheck(keys[0] == 123);
112:   PetscTestCheck(keys[1] == 321);
113:   PetscTestCheck(vals[0] == 24);
114:   PetscTestCheck(vals[1] == 42);
115:   PetscHMapIDestroy(&hd);

117:   PetscHMapISet(ht, 0, 0);
118:   PetscHMapIGetSize(ht, &n);
119:   PetscTestCheck(n != 0);
120:   PetscHMapIReset(ht);
121:   PetscHMapIGetSize(ht, &n);
122:   PetscTestCheck(n == 0);
123:   PetscHMapIReset(ht);
124:   PetscHMapIGetSize(ht, &n);
125:   PetscTestCheck(n == 0);
126:   PetscHMapISet(ht, 0, 0);
127:   PetscHMapIGetSize(ht, &n);
128:   PetscTestCheck(n != 0);

130:   PetscHMapIDestroy(&ht);
131:   PetscTestCheck(ht == NULL);

133:   PetscHMapICreate(&ht);
134:   PetscHMapIReset(ht);
135:   PetscHMapIGetSize(ht, &n);
136:   PetscTestCheck(n == 0);
137:   PetscHMapIDestroy(&ht);

139:   PetscHMapIVCreate(&htv);
140:   n = 10;
141:   PetscHMapIVResize(htv, n);
142:   PetscHMapIVGetCapacity(htv, &na);
143:   PetscTestCheck(na >= n);
144:   for (i = 0; i < n; i++) PetscHMapIVSet(htv, i + 100, 10.);

146:   PetscHMapIVGetCapacity(htv, &nb);
147:   PetscTestCheck(nb >= na);
148:   for (i = 0; i < (2 * n); i++) PetscHMapIVAddValue(htv, i + 100, 5.);

150:   PetscHMapIVGetSize(htv, &size);
151:   PetscTestCheck(size == (2 * n));
152:   PetscMalloc3(size, &karray, size, &varray, size, &vwork);
153:   off = 0;
154:   PetscHMapIVGetPairs(htv, &off, karray, varray);
155:   PetscTestCheck(off == (2 * n));
156:   PetscSortIntWithDataArray(off, karray, varray, sizeof(PetscScalar), vwork);
157:   for (i = 0; i < n; i++) {
158:     PetscTestCheck(karray[i] == (i + 100));
159:     PetscTestCheck(karray[n + i] == (n + i + 100));
160:     PetscTestCheck(varray[i] == 15.);
161:     PetscTestCheck(varray[n + i] == 5.);
162:   }
163:   PetscFree3(karray, varray, vwork);
164:   PetscHMapIVDestroy(&htv);

166:   PetscFinalize();
167:   return 0;
168: }

170: /*TEST

172:    test:

174: TEST*/