← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nwchem/trusty-proposed

« back to all changes in this revision

Viewing changes to src/tools/ga-5-2/global/src/capi.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Daniel Leidert, Andreas Tille, Michael Banck
  • Date: 2013-07-04 12:14:55 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130704121455-5tvsx2qabor3nrui
Tags: 6.3-1
http://bugs.debian.org/696361
* New upstream release.
* Fixes anisotropic properties (Closes: #696361).
* New features include:
  + Multi-reference coupled cluster (MRCC) approaches
  + Hybrid DFT calculations with short-range HF 
  + New density-functionals including Minnesota (M08, M11) and HSE hybrid
    functionals
  + X-ray absorption spectroscopy (XAS) with TDDFT
  + Analytical gradients for the COSMO solvation model
  + Transition densities from TDDFT 
  + DFT+U and Electron-Transfer (ET) methods for plane wave calculations
  + Exploitation of space group symmetry in plane wave geometry optimizations
  + Local density of states (LDOS) collective variable added to Metadynamics
  + Various new XC functionals added for plane wave calculations, including
    hybrid and range-corrected ones
  + Electric field gradients with relativistic corrections 
  + Nudged Elastic Band optimization method
  + Updated basis sets and ECPs 

[ Daniel Leidert ]
* debian/watch: Fixed.

[ Andreas Tille ]
* debian/upstream: References

[ Michael Banck ]
* debian/upstream (Name): New field.
* debian/patches/02_makefile_flags.patch: Refreshed.
* debian/patches/06_statfs_kfreebsd.patch: Likewise.
* debian/patches/07_ga_target_force_linux.patch: Likewise.
* debian/patches/05_avoid_inline_assembler.patch: Removed, no longer needed.
* debian/patches/09_backported_6.1.1_fixes.patch: Likewise.
* debian/control (Build-Depends): Added gfortran-4.7 and gcc-4.7.
* debian/patches/10_force_gcc-4.7.patch: New patch, explicitly sets
  gfortran-4.7 and gcc-4.7, fixes test suite hang with gcc-4.8 (Closes:
  #701328, #713262).
* debian/testsuite: Added tests for COSMO analytical gradients and MRCC.
* debian/rules (MRCC_METHODS): New variable, required to enable MRCC methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-5-2/global/src/capi.c
 
1
/**
 
2
 * @file capi.c
 
3
 *
 
4
 * Implements the C interface.
 
5
 * These calls forward to the (possibly) weak symbols of the internal
 
6
 * implementations.
 
7
 */
 
8
#if HAVE_CONFIG_H
 
9
#   include "config.h"
 
10
#endif
 
11
 
 
12
#if HAVE_STDIO_H
 
13
#   include <stdio.h>
 
14
#endif
 
15
#if HAVE_STDLIB_H
 
16
#   include <stdlib.h>
 
17
#endif
 
18
#include <assert.h>
 
19
 
 
20
#include "armci.h"
 
21
#include "ga.h"
 
22
#include "globalp.h"
 
23
#include "ga-papi.h"
 
24
#include "matmul.h"
 
25
 
 
26
#if ENABLE_PROFILING
 
27
#   include "ga-wapi.h"
 
28
#else
 
29
#   include "ga-wapidefs.h"
 
30
#endif
 
31
 
 
32
int *_ga_argc=NULL;
 
33
char ***_ga_argv=NULL;
 
34
int _ga_initialize_args=0;
 
35
int _ga_initialize_c=0;
 
36
 
 
37
short int _ga_irreg_flag = 0;
 
38
 
 
39
static Integer* copy_map(int block[], int block_ndim, int map[]);
 
40
static Integer* copy_map64(int64_t block[], int block_ndim, int64_t map[]);
 
41
 
 
42
#ifdef USE_FAPI
 
43
#  define COPYC2F(carr, farr, n){\
 
44
   int i; for(i=0; i< (n); i++)(farr)[i]=(Integer)(carr)[i];} 
 
45
#  define COPYF2C(farr, carr, n){\
 
46
   int i; for(i=0; i< (n); i++)(carr)[i]=(int)(farr)[i];} 
 
47
#  define COPYF2C_64(farr, carr, n){\
 
48
   int i; for(i=0; i< (n); i++)(carr)[i]=(int64_t)(farr)[i];} 
 
49
#  define COPYINDEX_F2C     COPYF2C
 
50
#  define COPYINDEX_F2C_64  COPYF2C_64
 
51
#else
 
52
#  define COPYC2F(carr, farr, n){\
 
53
   int i; for(i=0; i< (n); i++)(farr)[n-i-1]=(Integer)(carr)[i];} 
 
54
#  define COPYF2C(farr, carr, n){\
 
55
   int i; for(i=0; i< (n); i++)(carr)[n-i-1]=(int)(farr)[i];} 
 
56
#  define COPYF2C_64(farr, carr, n){\
 
57
   int i; for(i=0; i< (n); i++)(carr)[n-i-1]=(int64_t)(farr)[i];} 
 
58
#  define COPYINDEX_C2F(carr, farr, n){\
 
59
   int i; for(i=0; i< (n); i++)(farr)[n-i-1]=(Integer)(carr)[i]+1;}
 
60
#  define COPYINDEX_F2C(farr, carr, n){\
 
61
   int i; for(i=0; i< (n); i++)(carr)[n-i-1]=(int)(farr)[i] -1;}
 
62
#  define COPYINDEX_F2C_64(farr, carr, n){\
 
63
   int i; for(i=0; i< (n); i++)(carr)[n-i-1]=(int64_t)(farr)[i] -1;}
 
64
#define BASE_0
 
65
#endif
 
66
 
 
67
#define COPY(CAST,src,dst,n) {\
 
68
   int i; for(i=0; i< (n); i++)(dst)[i]=(CAST)(src)[i];} 
 
69
#define COPY_INC(CAST,src,dst,n) {\
 
70
   int i; for(i=0; i< (n); i++)(dst)[i]=(CAST)(src)[i]+1;} 
 
71
#define COPY_DEC(CAST,src,dst,n) {\
 
72
   int i; for(i=0; i< (n); i++)(dst)[i]=(CAST)(src)[i]-1;} 
 
73
 
 
74
int GA_Uses_fapi(void)
 
75
{
 
76
#ifdef USE_FAPI
 
77
return 1;
 
78
#else
 
79
return 0;
 
80
#endif
 
81
}
 
82
 
 
83
 
 
84
void GA_Initialize_ltd(size_t limit)
 
85
{
 
86
  Integer lim = (Integer)limit;
 
87
  _ga_initialize_c = 1;
 
88
  wnga_initialize_ltd(lim);
 
89
}
 
90
 
 
91
void NGA_Initialize_ltd(size_t limit)
 
92
{
 
93
  Integer lim = (Integer)limit;
 
94
  _ga_initialize_c = 1;
 
95
  wnga_initialize_ltd(lim);
 
96
}
 
97
 
 
98
void GA_Initialize_args(int *argc, char ***argv)
 
99
{
 
100
  _ga_argc = argc;
 
101
  _ga_argv = argv;
 
102
  _ga_initialize_c = 1;
 
103
  _ga_initialize_args = 1;
 
104
 
 
105
  wnga_initialize();
 
106
}
 
107
 
 
108
void GA_Initialize()
 
109
{
 
110
  _ga_initialize_c = 1;
 
111
  wnga_initialize();
 
112
}
 
113
 
 
114
void NGA_Initialize()
 
115
{
 
116
  _ga_initialize_c = 1;
 
117
  wnga_initialize();
 
118
}
 
119
 
 
120
int GA_Initialized()
 
121
{
 
122
    return wnga_initialized();
 
123
}
 
124
 
 
125
int NGA_Initialized()
 
126
{
 
127
    return wnga_initialized();
 
128
}
 
129
 
 
130
void GA_Terminate() 
 
131
{
 
132
    wnga_terminate();
 
133
    
 
134
    _ga_argc = NULL;
 
135
    _ga_argv = NULL;
 
136
    _ga_initialize_args = 0;
 
137
    _ga_initialize_c = 0;
 
138
}
 
139
 
 
140
void NGA_Terminate() 
 
141
{
 
142
    wnga_terminate();
 
143
    
 
144
    _ga_argc = NULL;
 
145
    _ga_argv = NULL;
 
146
    _ga_initialize_args = 0;
 
147
    _ga_initialize_c = 0;
 
148
}
 
149
 
 
150
int NGA_Create(int type, int ndim, int dims[], char *name, int *chunk)
 
151
{
 
152
    Integer *ptr, g_a; 
 
153
    logical st;
 
154
    Integer _ga_work[MAXDIM];
 
155
    Integer _ga_dims[MAXDIM];
 
156
    if(ndim>MAXDIM)return 0;
 
157
 
 
158
    COPYC2F(dims,_ga_dims, ndim);
 
159
    if(!chunk)ptr=(Integer*)0;  
 
160
    else {
 
161
         COPYC2F(chunk,_ga_work, ndim);
 
162
         ptr = _ga_work;
 
163
    }
 
164
    st = wnga_create((Integer)type, (Integer)ndim, _ga_dims, name, ptr, &g_a);
 
165
    if(st==TRUE) return (int) g_a;
 
166
    else return 0;
 
167
}
 
168
 
 
169
int NGA_Create64(int type, int ndim, int64_t dims[], char *name, int64_t *chunk)
 
170
{
 
171
    Integer *ptr, g_a; 
 
172
    logical st;
 
173
    Integer _ga_dims[MAXDIM];
 
174
    Integer _ga_work[MAXDIM];
 
175
    if(ndim>MAXDIM)return 0;
 
176
 
 
177
    COPYC2F(dims,_ga_dims, ndim);
 
178
    if(!chunk)ptr=(Integer*)0;  
 
179
    else {
 
180
         COPYC2F(chunk,_ga_work, ndim);
 
181
         ptr = _ga_work;
 
182
    }
 
183
    st = wnga_create((Integer)type, (Integer)ndim, _ga_dims, name, ptr, &g_a);
 
184
    if(st==TRUE) return (int) g_a;
 
185
    else return 0;
 
186
}
 
187
 
 
188
int NGA_Create_config(int type, int ndim, int dims[], char *name, int chunk[],
 
189
                      int p_handle)
 
190
{
 
191
    Integer *ptr, g_a; 
 
192
    logical st;
 
193
    Integer _ga_dims[MAXDIM];
 
194
    Integer _ga_work[MAXDIM];
 
195
    if(ndim>MAXDIM)return 0;
 
196
 
 
197
    COPYC2F(dims,_ga_dims, ndim);
 
198
    if(!chunk)ptr=(Integer*)0;  
 
199
    else {
 
200
         COPYC2F(chunk,_ga_work, ndim);
 
201
         ptr = _ga_work;
 
202
    }
 
203
    st = wnga_create_config((Integer)type, (Integer)ndim, _ga_dims, name, ptr,
 
204
                    (Integer)p_handle, &g_a);
 
205
    if(st==TRUE) return (int) g_a;
 
206
    else return 0;
 
207
}
 
208
 
 
209
 
 
210
int NGA_Create_config64(int type, int ndim, int64_t dims[], char *name, int64_t chunk[], int p_handle)
 
211
{
 
212
    Integer *ptr, g_a; 
 
213
    logical st;
 
214
    Integer _ga_dims[MAXDIM];
 
215
    Integer _ga_work[MAXDIM];
 
216
    if(ndim>MAXDIM)return 0;
 
217
 
 
218
    COPYC2F(dims,_ga_dims, ndim);
 
219
    if(!chunk)ptr=(Integer*)0;  
 
220
    else {
 
221
         COPYC2F(chunk,_ga_work, ndim);
 
222
         ptr = _ga_work;
 
223
    }
 
224
    st = wnga_create_config((Integer)type, (Integer)ndim, _ga_dims, name, ptr,
 
225
                    (Integer)p_handle, &g_a);
 
226
    if(st==TRUE) return (int) g_a;
 
227
    else return 0;
 
228
}
 
229
 
 
230
int NGA_Create_irreg(int type,int ndim,int dims[],char *name,int block[],int map[])
 
231
{
 
232
    Integer g_a;
 
233
    logical st;
 
234
    Integer _ga_dims[MAXDIM];
 
235
    Integer _ga_work[MAXDIM];
 
236
    Integer *_ga_map_capi;
 
237
    if(ndim>MAXDIM)return 0;
 
238
 
 
239
    COPYC2F(dims,_ga_dims, ndim);
 
240
    COPYC2F(block,_ga_work, ndim);
 
241
    _ga_map_capi = copy_map(block, ndim, map);
 
242
 
 
243
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
244
    st = wnga_create_irreg(type, (Integer)ndim, _ga_dims, name, _ga_map_capi,
 
245
            _ga_work, &g_a);
 
246
    _ga_irreg_flag = 0; /* unset it after creating the array */
 
247
 
 
248
    free(_ga_map_capi);
 
249
    if(st==TRUE) return (int) g_a;
 
250
    else return 0;
 
251
}
 
252
 
 
253
int NGA_Create_irreg64(int type,int ndim,int64_t dims[],char *name,int64_t block[],int64_t map[])
 
254
{
 
255
    Integer g_a;
 
256
    logical st;
 
257
    Integer _ga_dims[MAXDIM];
 
258
    Integer _ga_work[MAXDIM];
 
259
    Integer *_ga_map_capi;
 
260
    if(ndim>MAXDIM)return 0;
 
261
 
 
262
    COPYC2F(dims,_ga_dims, ndim);
 
263
    COPYC2F(block,_ga_work, ndim);
 
264
    _ga_map_capi = copy_map64(block, ndim, map);
 
265
 
 
266
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
267
    st = wnga_create_irreg(type, (Integer)ndim, _ga_dims, name, _ga_map_capi,
 
268
            _ga_work, &g_a);
 
269
    _ga_irreg_flag = 0; /* unset it after creating the array */
 
270
 
 
271
    free(_ga_map_capi);
 
272
    if(st==TRUE) return (int) g_a;
 
273
    else return 0;
 
274
}
 
275
 
 
276
int NGA_Create_irreg_config(int type,int ndim,int dims[],char *name,int block[],
 
277
                            int map[], int p_handle)
 
278
{
 
279
    Integer g_a;
 
280
    logical st;
 
281
    Integer _ga_dims[MAXDIM];
 
282
    Integer _ga_work[MAXDIM];
 
283
    Integer *_ga_map_capi;
 
284
    if(ndim>MAXDIM)return 0;
 
285
 
 
286
    COPYC2F(dims,_ga_dims, ndim);
 
287
    COPYC2F(block,_ga_work, ndim);
 
288
    _ga_map_capi = copy_map(block, ndim, map);
 
289
 
 
290
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
291
    st = wnga_create_irreg_config(type, (Integer)ndim, _ga_dims, name,
 
292
            _ga_map_capi, _ga_work, (Integer)p_handle, &g_a);
 
293
    _ga_irreg_flag = 0; /* unset it, after creating array */
 
294
 
 
295
    free(_ga_map_capi);
 
296
    if(st==TRUE) return (int) g_a;
 
297
    else return 0;
 
298
}
 
299
 
 
300
int NGA_Create_irreg_config64(int type,int ndim,int64_t dims[],char *name,int64_t block[], int64_t map[], int p_handle)
 
301
{
 
302
    Integer g_a;
 
303
    logical st;
 
304
    Integer _ga_dims[MAXDIM];
 
305
    Integer _ga_work[MAXDIM];
 
306
    Integer *_ga_map_capi;
 
307
    if(ndim>MAXDIM)return 0;
 
308
 
 
309
    COPYC2F(dims,_ga_dims, ndim);
 
310
    COPYC2F(block,_ga_work, ndim);
 
311
    _ga_map_capi = copy_map64(block, ndim, map);
 
312
 
 
313
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
314
    st = wnga_create_irreg_config(type, (Integer)ndim, _ga_dims, name,
 
315
            _ga_map_capi, _ga_work, (Integer)p_handle, &g_a);
 
316
    _ga_irreg_flag = 0; /* unset it, after creating array */
 
317
 
 
318
    free(_ga_map_capi);
 
319
    if(st==TRUE) return (int) g_a;
 
320
    else return 0;
 
321
}
 
322
 
 
323
int NGA_Create_ghosts_irreg(int type,int ndim,int dims[],int width[],char *name, int block[],int map[])
 
324
{
 
325
    Integer g_a;
 
326
    logical st;
 
327
    Integer _ga_dims[MAXDIM];
 
328
    Integer _ga_work[MAXDIM];
 
329
    Integer _ga_width[MAXDIM];
 
330
    Integer *_ga_map_capi;
 
331
    if(ndim>MAXDIM)return 0;
 
332
 
 
333
    COPYC2F(dims,_ga_dims, ndim);
 
334
    COPYC2F(block,_ga_work, ndim);
 
335
    COPYC2F(width,_ga_width, ndim);
 
336
    _ga_map_capi = copy_map(block, ndim, map);
 
337
 
 
338
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
339
    st = wnga_create_ghosts_irreg(type, (Integer)ndim, _ga_dims, _ga_width,
 
340
            name, _ga_map_capi, _ga_work, &g_a);
 
341
    _ga_irreg_flag = 0; /* unset it, after creating array */ 
 
342
 
 
343
    free(_ga_map_capi);
 
344
    if(st==TRUE) return (int) g_a;
 
345
    else return 0;
 
346
}
 
347
 
 
348
int NGA_Create_ghosts_irreg64(int type,int ndim,int64_t dims[],int64_t width[],char *name, int64_t block[],int64_t map[])
 
349
{
 
350
    Integer g_a;
 
351
    logical st;
 
352
    Integer _ga_dims[MAXDIM];
 
353
    Integer _ga_work[MAXDIM];
 
354
    Integer _ga_width[MAXDIM];
 
355
    Integer *_ga_map_capi;
 
356
    if(ndim>MAXDIM)return 0;
 
357
 
 
358
    COPYC2F(dims,_ga_dims, ndim);
 
359
    COPYC2F(block,_ga_work, ndim);
 
360
    COPYC2F(width,_ga_width, ndim);
 
361
    _ga_map_capi = copy_map64(block, ndim, map);
 
362
 
 
363
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
364
    st = wnga_create_ghosts_irreg(type, (Integer)ndim, _ga_dims, _ga_width,
 
365
            name, _ga_map_capi, _ga_work, &g_a);
 
366
    _ga_irreg_flag = 0; /* unset it, after creating array */ 
 
367
     
 
368
    free(_ga_map_capi);
 
369
    if(st==TRUE) return (int) g_a;
 
370
    else return 0;
 
371
}
 
372
 
 
373
int NGA_Create_ghosts_irreg_config(int type, int ndim, int dims[], int width[], char *name, int block[], int map[], int p_handle)
 
374
{
 
375
    Integer g_a;
 
376
    logical st;
 
377
    Integer _ga_dims[MAXDIM];
 
378
    Integer _ga_work[MAXDIM];
 
379
    Integer _ga_width[MAXDIM];
 
380
    Integer *_ga_map_capi;
 
381
    if(ndim>MAXDIM)return 0;
 
382
 
 
383
    COPYC2F(dims,_ga_dims, ndim);
 
384
    COPYC2F(block,_ga_work, ndim);
 
385
    COPYC2F(width,_ga_width, ndim);
 
386
    _ga_map_capi = copy_map(block, ndim, map);
 
387
 
 
388
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
389
    st = wnga_create_ghosts_irreg_config(type, (Integer)ndim, _ga_dims,
 
390
                                         _ga_width, name, _ga_map_capi, _ga_work, 
 
391
                                         (Integer)p_handle, &g_a);
 
392
    _ga_irreg_flag = 0; /* unset it, after creating array */ 
 
393
 
 
394
    free(_ga_map_capi);
 
395
    if(st==TRUE) return (int) g_a;
 
396
    else return 0;
 
397
}
 
398
 
 
399
int NGA_Create_ghosts_irreg_config64(int type, int ndim, int64_t dims[], int64_t width[], char *name, int64_t block[], int64_t map[], int p_handle)
 
400
{
 
401
    Integer g_a;
 
402
    logical st;
 
403
    Integer _ga_dims[MAXDIM];
 
404
    Integer _ga_work[MAXDIM];
 
405
    Integer _ga_width[MAXDIM];
 
406
    Integer *_ga_map_capi;
 
407
    if(ndim>MAXDIM)return 0;
 
408
 
 
409
    COPYC2F(dims,_ga_dims, ndim);
 
410
    COPYC2F(block,_ga_work, ndim);
 
411
    COPYC2F(width,_ga_width, ndim);
 
412
    _ga_map_capi = copy_map64(block, ndim, map);
 
413
 
 
414
    _ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
 
415
    st = wnga_create_ghosts_irreg_config(type, (Integer)ndim, _ga_dims,
 
416
                                         _ga_width, name, _ga_map_capi, _ga_work, 
 
417
                                         (Integer)p_handle, &g_a);
 
418
    _ga_irreg_flag = 0; /* unset it, after creating array */ 
 
419
 
 
420
    free(_ga_map_capi);
 
421
    if(st==TRUE) return (int) g_a;
 
422
    else return 0;
 
423
}
 
424
 
 
425
int NGA_Create_ghosts(int type, int ndim,int dims[], int width[], char *name,
 
426
    int chunk[])
 
427
{
 
428
    Integer *ptr, g_a; 
 
429
    logical st;
 
430
    Integer _ga_dims[MAXDIM];
 
431
    Integer _ga_work[MAXDIM];
 
432
    Integer _ga_width[MAXDIM];
 
433
    if(ndim>MAXDIM)return 0;
 
434
 
 
435
    COPYC2F(dims,_ga_dims, ndim);
 
436
    COPYC2F(width,_ga_width, ndim);
 
437
    if(!chunk)ptr=(Integer*)0;  
 
438
    else {
 
439
         COPYC2F(chunk,_ga_work, ndim);
 
440
         ptr = _ga_work;
 
441
    }
 
442
    st = wnga_create_ghosts((Integer)type, (Integer)ndim, _ga_dims,
 
443
        _ga_width, name, ptr, &g_a);
 
444
    if(st==TRUE) return (int) g_a;
 
445
    else return 0;
 
446
}
 
447
 
 
448
 
 
449
int NGA_Create_ghosts64(int type, int ndim, int64_t dims[], int64_t width[], char *name,
 
450
    int64_t chunk[])
 
451
{
 
452
    Integer *ptr, g_a; 
 
453
    logical st;
 
454
    Integer _ga_dims[MAXDIM];
 
455
    Integer _ga_work[MAXDIM];
 
456
    Integer _ga_width[MAXDIM];
 
457
    if(ndim>MAXDIM)return 0;
 
458
 
 
459
    COPYC2F(dims,_ga_dims, ndim);
 
460
    COPYC2F(width,_ga_width, ndim);
 
461
    if(!chunk)ptr=(Integer*)0;  
 
462
    else {
 
463
         COPYC2F(chunk,_ga_work, ndim);
 
464
         ptr = _ga_work;
 
465
    }
 
466
    st = wnga_create_ghosts((Integer)type, (Integer)ndim, _ga_dims,
 
467
        _ga_width, name, ptr, &g_a);
 
468
    if(st==TRUE) return (int) g_a;
 
469
    else return 0;
 
470
}
 
471
 
 
472
 
 
473
int NGA_Create_ghosts_config(int type, int ndim,int dims[], int width[], char *name,
 
474
    int chunk[], int p_handle)
 
475
{
 
476
    Integer *ptr, g_a; 
 
477
    logical st;
 
478
    Integer _ga_dims[MAXDIM];
 
479
    Integer _ga_work[MAXDIM];
 
480
    Integer _ga_width[MAXDIM];
 
481
    if(ndim>MAXDIM)return 0;
 
482
 
 
483
    COPYC2F(dims,_ga_dims, ndim);
 
484
    COPYC2F(width,_ga_width, ndim);
 
485
    if(!chunk)ptr=(Integer*)0;  
 
486
    else {
 
487
         COPYC2F(chunk,_ga_work, ndim);
 
488
         ptr = _ga_work;
 
489
    }
 
490
    st = wnga_create_ghosts_config((Integer)type, (Integer)ndim, _ga_dims,
 
491
        _ga_width, name, ptr, (Integer)p_handle, &g_a);
 
492
    if(st==TRUE) return (int) g_a;
 
493
    else return 0;
 
494
}
 
495
 
 
496
int NGA_Create_ghosts_config64(int type, int ndim,int64_t  dims[], int64_t width[], char *name,
 
497
    int64_t chunk[], int p_handle)
 
498
{
 
499
    Integer *ptr, g_a; 
 
500
    logical st;
 
501
    Integer _ga_dims[MAXDIM];
 
502
    Integer _ga_work[MAXDIM];
 
503
    Integer _ga_width[MAXDIM];
 
504
    if(ndim>MAXDIM)return 0;
 
505
 
 
506
    COPYC2F(dims,_ga_dims, ndim);
 
507
    COPYC2F(width,_ga_width, ndim);
 
508
    if(!chunk)ptr=(Integer*)0;  
 
509
    else {
 
510
         COPYC2F(chunk,_ga_work, ndim);
 
511
         ptr = _ga_work;
 
512
    }
 
513
    st = wnga_create_ghosts_config((Integer)type, (Integer)ndim, _ga_dims,
 
514
        _ga_width, name, ptr, (Integer)p_handle, &g_a);
 
515
    if(st==TRUE) return (int) g_a;
 
516
    else return 0;
 
517
}
 
518
 
 
519
int GA_Create_handle()
 
520
{
 
521
    Integer g_a;
 
522
    g_a = wnga_create_handle();
 
523
    return (int)g_a;
 
524
}
 
525
 
 
526
int NGA_Create_handle()
 
527
{
 
528
    Integer g_a;
 
529
    g_a = wnga_create_handle();
 
530
    return (int)g_a;
 
531
}
 
532
 
 
533
void GA_Set_data(int g_a, int ndim, int dims[], int type)
 
534
{
 
535
    Integer aa, nndim, ttype;
 
536
    Integer _ga_dims[MAXDIM];
 
537
    COPYC2F(dims,_ga_dims, ndim);
 
538
    aa = (Integer)g_a;
 
539
    nndim = (Integer)ndim;
 
540
    ttype = (Integer)type;
 
541
    wnga_set_data(aa, nndim, _ga_dims, ttype);
 
542
}
 
543
 
 
544
void GA_Set_data64(int g_a, int ndim, int64_t dims[], int type)
 
545
{
 
546
    Integer aa, nndim, ttype;
 
547
    Integer _ga_dims[MAXDIM];
 
548
    COPYC2F(dims,_ga_dims, ndim);
 
549
    aa = (Integer)g_a;
 
550
    nndim = (Integer)ndim;
 
551
    ttype = (Integer)type;
 
552
    wnga_set_data(aa, nndim, _ga_dims, ttype);
 
553
}
 
554
 
 
555
void NGA_Set_data(int g_a, int ndim, int dims[], int type)
 
556
{
 
557
    Integer aa, nndim, ttype;
 
558
    Integer _ga_dims[MAXDIM];
 
559
    COPYC2F(dims,_ga_dims, ndim);
 
560
    aa = (Integer)g_a;
 
561
    nndim = (Integer)ndim;
 
562
    ttype = (Integer)type;
 
563
    wnga_set_data(aa, nndim, _ga_dims, ttype);
 
564
}
 
565
 
 
566
void NGA_Set_data64(int g_a, int ndim, int64_t dims[], int type)
 
567
{
 
568
    Integer aa, nndim, ttype;
 
569
    Integer _ga_dims[MAXDIM];
 
570
    COPYC2F(dims,_ga_dims, ndim);
 
571
    aa = (Integer)g_a;
 
572
    nndim = (Integer)ndim;
 
573
    ttype = (Integer)type;
 
574
    wnga_set_data(aa, nndim, _ga_dims, ttype);
 
575
}
 
576
 
 
577
void GA_Set_chunk(int g_a, int chunk[])
 
578
{
 
579
    Integer aa, *ptr, ndim;
 
580
    Integer _ga_work[MAXDIM];
 
581
    aa = (Integer)g_a;
 
582
    ndim = wnga_get_dimension(aa);
 
583
    if(!chunk)ptr=(Integer*)0;  
 
584
    else {
 
585
      COPYC2F(chunk,_ga_work, ndim);
 
586
      ptr = _ga_work;
 
587
    }
 
588
    wnga_set_chunk(aa, ptr);
 
589
}
 
590
 
 
591
void GA_Set_chunk64(int g_a, int64_t chunk[])
 
592
{
 
593
    Integer aa, *ptr, ndim;
 
594
    Integer _ga_work[MAXDIM];
 
595
    aa = (Integer)g_a;
 
596
    ndim = wnga_get_dimension(aa);
 
597
    if(!chunk)ptr=(Integer*)0;  
 
598
    else {
 
599
      COPYC2F(chunk,_ga_work, ndim);
 
600
      ptr = _ga_work;
 
601
    }
 
602
    wnga_set_chunk(aa, ptr);
 
603
}
 
604
 
 
605
void NGA_Set_chunk(int g_a, int chunk[])
 
606
{
 
607
    Integer aa, *ptr, ndim;
 
608
    Integer _ga_work[MAXDIM];
 
609
    aa = (Integer)g_a;
 
610
    ndim = wnga_get_dimension(aa);
 
611
    if(!chunk)ptr=(Integer*)0;  
 
612
    else {
 
613
      COPYC2F(chunk,_ga_work, ndim);
 
614
      ptr = _ga_work;
 
615
    }
 
616
    wnga_set_chunk(aa, ptr);
 
617
}
 
618
 
 
619
void NGA_Set_chunk64(int g_a, int64_t chunk[])
 
620
{
 
621
    Integer aa, *ptr, ndim;
 
622
    Integer _ga_work[MAXDIM];
 
623
    aa = (Integer)g_a;
 
624
    ndim = wnga_get_dimension(aa);
 
625
    if(!chunk)ptr=(Integer*)0;  
 
626
    else {
 
627
      COPYC2F(chunk,_ga_work, ndim);
 
628
      ptr = _ga_work;
 
629
    }
 
630
    wnga_set_chunk(aa, ptr);
 
631
}
 
632
 
 
633
void GA_Set_array_name(int g_a, char *name)
 
634
{
 
635
    Integer aa;
 
636
    aa = (Integer)g_a;
 
637
    wnga_set_array_name(aa, name);
 
638
}
 
639
 
 
640
void NGA_Set_array_name(int g_a, char *name)
 
641
{
 
642
    Integer aa;
 
643
    aa = (Integer)g_a;
 
644
    wnga_set_array_name(aa, name);
 
645
}
 
646
 
 
647
void GA_Set_pgroup(int g_a, int p_handle)
 
648
{
 
649
  Integer aa, pp;
 
650
  aa = (Integer)g_a;
 
651
  pp = (Integer)p_handle;
 
652
  wnga_set_pgroup(aa, pp);
 
653
}
 
654
 
 
655
void NGA_Set_pgroup(int g_a, int p_handle)
 
656
{
 
657
  Integer aa, pp;
 
658
  aa = (Integer)g_a;
 
659
  pp = (Integer)p_handle;
 
660
  wnga_set_pgroup(aa, pp);
 
661
}
 
662
 
 
663
void GA_Set_block_cyclic(int g_a, int dims[])
 
664
{
 
665
    Integer aa, ndim;
 
666
    Integer _ga_dims[MAXDIM];
 
667
    aa = (Integer)g_a;
 
668
    ndim = wnga_get_dimension(aa);
 
669
    COPYC2F(dims,_ga_dims, ndim);
 
670
    wnga_set_block_cyclic(aa, _ga_dims);
 
671
}
 
672
 
 
673
void NGA_Set_block_cyclic(int g_a, int dims[])
 
674
{
 
675
    Integer aa, ndim;
 
676
    Integer _ga_dims[MAXDIM];
 
677
    aa = (Integer)g_a;
 
678
    ndim = wnga_get_dimension(aa);
 
679
    COPYC2F(dims,_ga_dims, ndim);
 
680
    wnga_set_block_cyclic(aa, _ga_dims);
 
681
}
 
682
 
 
683
void GA_Set_restricted(int g_a, int list[], int size)
 
684
{
 
685
    Integer aa;
 
686
    Integer asize = (Integer)size;
 
687
    int i;
 
688
    Integer *_ga_map_capi;
 
689
    aa = (Integer)g_a;
 
690
    _ga_map_capi = (Integer*)malloc(size * sizeof(Integer));
 
691
    for (i=0; i<size; i++)
 
692
       _ga_map_capi[i] = (Integer)list[i];
 
693
    wnga_set_restricted(aa,_ga_map_capi,asize);
 
694
    free(_ga_map_capi);
 
695
}
 
696
 
 
697
void NGA_Set_restricted(int g_a, int list[], int size)
 
698
{
 
699
    Integer aa;
 
700
    Integer asize = (Integer)size;
 
701
    int i;
 
702
    Integer *_ga_map_capi;
 
703
    aa = (Integer)g_a;
 
704
    _ga_map_capi = (Integer*)malloc(size * sizeof(Integer));
 
705
    for (i=0; i<size; i++)
 
706
       _ga_map_capi[i] = (Integer)list[i];
 
707
    wnga_set_restricted(aa,_ga_map_capi,asize);
 
708
    free(_ga_map_capi);
 
709
}
 
710
 
 
711
void GA_Set_restricted_range(int g_a, int lo_proc, int hi_proc)
 
712
{
 
713
    Integer aa, lo, hi;
 
714
    aa = (Integer)g_a;
 
715
    lo = (Integer)lo_proc;
 
716
    hi = (Integer)hi_proc;
 
717
    wnga_set_restricted_range(aa,lo,hi);
 
718
}
 
719
 
 
720
void NGA_Set_restricted_range(int g_a, int lo_proc, int hi_proc)
 
721
{
 
722
    Integer aa, lo, hi;
 
723
    aa = (Integer)g_a;
 
724
    lo = (Integer)lo_proc;
 
725
    hi = (Integer)hi_proc;
 
726
    wnga_set_restricted_range(aa,lo,hi);
 
727
}
 
728
 
 
729
int GA_Total_blocks(int g_a)
 
730
{
 
731
    Integer aa;
 
732
    aa = (Integer)g_a;
 
733
    return (int)wnga_total_blocks(aa);
 
734
}
 
735
 
 
736
int NGA_Total_blocks(int g_a)
 
737
{
 
738
    Integer aa;
 
739
    aa = (Integer)g_a;
 
740
    return (int)wnga_total_blocks(aa);
 
741
}
 
742
 
 
743
void GA_Get_proc_index(int g_a, int iproc, int index[])
 
744
{
 
745
     Integer aa, proc, ndim;
 
746
     Integer _ga_work[MAXDIM];
 
747
     aa = (Integer)g_a;
 
748
     proc = (Integer)iproc;
 
749
     ndim = wnga_get_dimension(aa);
 
750
     wnga_get_proc_index(aa, proc, _ga_work);
 
751
     COPYF2C(_ga_work,index, ndim);
 
752
}
 
753
 
 
754
void NGA_Get_proc_index(int g_a, int iproc, int index[])
 
755
{
 
756
     Integer aa, proc, ndim;
 
757
     Integer _ga_work[MAXDIM];
 
758
     aa = (Integer)g_a;
 
759
     proc = (Integer)iproc;
 
760
     ndim = wnga_get_dimension(aa);
 
761
     wnga_get_proc_index(aa, proc, _ga_work);
 
762
     COPYF2C(_ga_work,index, ndim);
 
763
}
 
764
 
 
765
void GA_Get_block_info(int g_a, int num_blocks[], int block_dims[])
 
766
{
 
767
     Integer aa, ndim;
 
768
     Integer _ga_work[MAXDIM], _ga_lo[MAXDIM];
 
769
     aa = (Integer)g_a;
 
770
     ndim = wnga_get_dimension(aa);
 
771
     wnga_get_block_info(aa, _ga_work, _ga_lo);
 
772
     COPYF2C(_ga_work,num_blocks, ndim);
 
773
     COPYF2C(_ga_lo,block_dims, ndim);
 
774
}
 
775
 
 
776
void NGA_Get_block_info(int g_a, int num_blocks[], int block_dims[])
 
777
{
 
778
     Integer aa, ndim;
 
779
     Integer _ga_work[MAXDIM], _ga_lo[MAXDIM];
 
780
     aa = (Integer)g_a;
 
781
     ndim = wnga_get_dimension(aa);
 
782
     wnga_get_block_info(aa, _ga_work, _ga_lo);
 
783
     COPYF2C(_ga_work,num_blocks, ndim);
 
784
     COPYF2C(_ga_lo,block_dims, ndim);
 
785
}
 
786
 
 
787
int GA_Uses_proc_grid(int g_a)
 
788
{
 
789
     Integer aa = (Integer)g_a;
 
790
     return (int)wnga_uses_proc_grid(aa);
 
791
}
 
792
 
 
793
int NGA_Uses_proc_grid(int g_a)
 
794
{
 
795
     Integer aa = (Integer)g_a;
 
796
     return (int)wnga_uses_proc_grid(aa);
 
797
}
 
798
 
 
799
int GA_Valid_handle(int g_a)
 
800
{
 
801
     Integer aa = (Integer)g_a;
 
802
     return (int)wnga_valid_handle(aa);
 
803
}
 
804
 
 
805
int NGA_Valid_handle(int g_a)
 
806
{
 
807
     Integer aa = (Integer)g_a;
 
808
     return (int)wnga_valid_handle(aa);
 
809
}
 
810
 
 
811
int GA_Verify_handle(int g_a)
 
812
{
 
813
     Integer aa = (Integer)g_a;
 
814
     return (int)wnga_valid_handle(aa);
 
815
}
 
816
 
 
817
int NGA_Verify_handle(int g_a)
 
818
{
 
819
     Integer aa = (Integer)g_a;
 
820
     return (int)wnga_valid_handle(aa);
 
821
}
 
822
 
 
823
void GA_Set_block_cyclic_proc_grid(int g_a, int block[], int proc_grid[])
 
824
{
 
825
    Integer aa, ndim;
 
826
    Integer _ga_dims[MAXDIM];
 
827
    Integer _ga_lo[MAXDIM];
 
828
    aa = (Integer)g_a;
 
829
    ndim = wnga_get_dimension(aa);
 
830
    COPYC2F(block,_ga_dims, ndim);
 
831
    COPYC2F(proc_grid,_ga_lo, ndim);
 
832
    wnga_set_block_cyclic_proc_grid(aa, _ga_dims, _ga_lo);
 
833
}
 
834
 
 
835
void NGA_Set_block_cyclic_proc_grid(int g_a, int block[], int proc_grid[])
 
836
{
 
837
    Integer aa, ndim;
 
838
    Integer _block[MAXDIM];
 
839
    Integer _proc_grid[MAXDIM];
 
840
    aa = (Integer)g_a;
 
841
    ndim = wnga_get_dimension(aa);
 
842
    COPYC2F(block,_block, ndim);
 
843
    COPYC2F(proc_grid, _proc_grid, ndim);
 
844
    wnga_set_block_cyclic_proc_grid(aa, _block, _proc_grid);
 
845
}
 
846
 
 
847
int GA_Get_pgroup(int g_a)
 
848
{
 
849
    Integer aa;
 
850
    aa = (Integer)g_a;
 
851
    return (int)wnga_get_pgroup(aa);
 
852
}
 
853
 
 
854
int NGA_Get_pgroup(int g_a)
 
855
{
 
856
    Integer aa;
 
857
    aa = (Integer)g_a;
 
858
    return (int)wnga_get_pgroup(aa);
 
859
}
 
860
 
 
861
int GA_Get_pgroup_size(int grp_id)
 
862
{
 
863
    Integer aa;
 
864
    aa = (Integer)grp_id;
 
865
    return (int)wnga_get_pgroup_size(aa);
 
866
}
 
867
 
 
868
int NGA_Get_pgroup_size(int grp_id)
 
869
{
 
870
    Integer aa;
 
871
    aa = (Integer)grp_id;
 
872
    return (int)wnga_get_pgroup_size(aa);
 
873
}
 
874
 
 
875
void GA_Set_ghosts(int g_a, int width[])
 
876
{
 
877
    Integer aa, *ptr, ndim;
 
878
    Integer _ga_work[MAXDIM];
 
879
    aa = (Integer)g_a;
 
880
    ndim = wnga_get_dimension(aa);
 
881
    if(!width)ptr=(Integer*)0;  
 
882
    else {
 
883
      COPYC2F(width,_ga_work, ndim);
 
884
      ptr = _ga_work;
 
885
    }
 
886
    wnga_set_ghosts(aa, ptr);
 
887
}
 
888
 
 
889
void GA_Set_ghosts64(int g_a, int64_t width[])
 
890
{
 
891
    Integer aa, *ptr, ndim;
 
892
    Integer _ga_work[MAXDIM];
 
893
    aa = (Integer)g_a;
 
894
    ndim = wnga_get_dimension(aa);
 
895
    if(!width)ptr=(Integer*)0;  
 
896
    else {
 
897
      COPYC2F(width,_ga_work, ndim);
 
898
      ptr = _ga_work;
 
899
    }
 
900
    wnga_set_ghosts(aa, ptr);
 
901
}
 
902
 
 
903
void NGA_Set_ghosts(int g_a, int width[])
 
904
{
 
905
    Integer aa, *ptr, ndim;
 
906
    Integer _ga_work[MAXDIM];
 
907
    aa = (Integer)g_a;
 
908
    ndim = wnga_get_dimension(aa);
 
909
    if(!width)ptr=(Integer*)0;  
 
910
    else {
 
911
      COPYC2F(width,_ga_work, ndim);
 
912
      ptr = _ga_work;
 
913
    }
 
914
    wnga_set_ghosts(aa, ptr);
 
915
}
 
916
 
 
917
void NGA_Set_ghosts64(int g_a, int64_t width[])
 
918
{
 
919
    Integer aa, *ptr, ndim;
 
920
    Integer _ga_work[MAXDIM];
 
921
    aa = (Integer)g_a;
 
922
    ndim = wnga_get_dimension(aa);
 
923
    if(!width)ptr=(Integer*)0;  
 
924
    else {
 
925
      COPYC2F(width,_ga_work, ndim);
 
926
      ptr = _ga_work;
 
927
    }
 
928
    wnga_set_ghosts(aa, ptr);
 
929
}
 
930
 
 
931
void GA_Set_irreg_distr(int g_a, int map[], int block[])
 
932
{
 
933
    Integer aa, ndim;
 
934
    Integer _ga_work[MAXDIM];
 
935
    Integer *_ga_map_capi;
 
936
 
 
937
    aa = (Integer)g_a;
 
938
    ndim = wnga_get_dimension(aa);
 
939
    COPYC2F(block,_ga_work, ndim);
 
940
    _ga_map_capi = copy_map(block, (int)ndim, map);
 
941
 
 
942
    wnga_set_irreg_distr(aa, _ga_map_capi, _ga_work);
 
943
    free(_ga_map_capi);
 
944
}
 
945
 
 
946
void GA_Set_irreg_distr64(int g_a, int64_t map[], int64_t block[])
 
947
{
 
948
    Integer aa, ndim;
 
949
    Integer _ga_work[MAXDIM];
 
950
    Integer *_ga_map_capi;
 
951
 
 
952
    aa = (Integer)g_a;
 
953
    ndim = wnga_get_dimension(aa);
 
954
    COPYC2F(block,_ga_work, ndim);
 
955
    _ga_map_capi = copy_map64(block, (int)ndim, map);
 
956
 
 
957
    wnga_set_irreg_distr(aa, _ga_map_capi, _ga_work);
 
958
    free(_ga_map_capi);
 
959
}
 
960
 
 
961
void NGA_Set_irreg_distr(int g_a, int map[], int block[])
 
962
{
 
963
    Integer aa, ndim;
 
964
    Integer _ga_work[MAXDIM];
 
965
    Integer *_ga_map_capi;
 
966
 
 
967
    aa = (Integer)g_a;
 
968
    ndim = wnga_get_dimension(aa);
 
969
    COPYC2F(block,_ga_work, ndim);
 
970
    _ga_map_capi = copy_map(block, (int)ndim, map);
 
971
 
 
972
    wnga_set_irreg_distr(aa, _ga_map_capi, _ga_work);
 
973
    free(_ga_map_capi);
 
974
}
 
975
 
 
976
void NGA_Set_irreg_distr64(int g_a, int64_t map[], int64_t block[])
 
977
{
 
978
    Integer aa, ndim;
 
979
    Integer _ga_work[MAXDIM];
 
980
    Integer *_ga_map_capi;
 
981
 
 
982
    aa = (Integer)g_a;
 
983
    ndim = wnga_get_dimension(aa);
 
984
    COPYC2F(block,_ga_work, ndim);
 
985
    _ga_map_capi = copy_map64(block, (int)ndim, map);
 
986
 
 
987
    wnga_set_irreg_distr(aa, _ga_map_capi, _ga_work);
 
988
    free(_ga_map_capi);
 
989
}
 
990
 
 
991
void GA_Set_irreg_flag(int g_a, int flag)
 
992
{
 
993
  Integer aa;
 
994
  logical fflag;
 
995
  aa = (Integer)g_a;
 
996
  fflag = (logical)flag;
 
997
  wnga_set_irreg_flag(aa, fflag);
 
998
}
 
999
 
 
1000
void NGA_Set_irreg_flag(int g_a, int flag)
 
1001
{
 
1002
  Integer aa;
 
1003
  logical fflag;
 
1004
  aa = (Integer)g_a;
 
1005
  fflag = (logical)flag;
 
1006
  wnga_set_irreg_flag(aa, fflag);
 
1007
}
 
1008
 
 
1009
void GA_Set_ghost_corner_flag(int g_a, int flag)
 
1010
{
 
1011
  Integer aa;
 
1012
  logical fflag;
 
1013
  aa = (Integer)g_a;
 
1014
  fflag = (logical)flag;
 
1015
  wnga_set_ghost_corner_flag(aa, fflag);
 
1016
}
 
1017
 
 
1018
void NGA_Set_ghost_corner_flag(int g_a, int flag)
 
1019
{
 
1020
  Integer aa;
 
1021
  logical fflag;
 
1022
  aa = (Integer)g_a;
 
1023
  fflag = (logical)flag;
 
1024
  wnga_set_ghost_corner_flag(aa, fflag);
 
1025
}
 
1026
 
 
1027
int GA_Get_dimension(int g_a)
 
1028
{
 
1029
  Integer aa;
 
1030
  aa = (Integer)g_a;
 
1031
  return (int)wnga_get_dimension(aa);
 
1032
}
 
1033
 
 
1034
int NGA_Get_dimension(int g_a)
 
1035
{
 
1036
  Integer aa;
 
1037
  aa = (Integer)g_a;
 
1038
  return (int)wnga_get_dimension(aa);
 
1039
}
 
1040
 
 
1041
int GA_Allocate(int g_a)
 
1042
{
 
1043
  Integer aa;
 
1044
  aa = (Integer)g_a;
 
1045
  return (int)wnga_allocate(aa);
 
1046
}
 
1047
 
 
1048
int NGA_Allocate(int g_a)
 
1049
{
 
1050
  Integer aa;
 
1051
  aa = (Integer)g_a;
 
1052
  return (int)wnga_allocate(aa);
 
1053
}
 
1054
 
 
1055
int GA_Pgroup_nodeid(int grp_id)
 
1056
{
 
1057
    Integer agrp_id = (Integer)grp_id;
 
1058
    return (int)wnga_pgroup_nodeid(agrp_id);
 
1059
}
 
1060
 
 
1061
int NGA_Pgroup_nodeid(int grp_id)
 
1062
{
 
1063
    Integer agrp_id = (Integer)grp_id;
 
1064
    return (int)wnga_pgroup_nodeid(agrp_id);
 
1065
}
 
1066
 
 
1067
int GA_Pgroup_nnodes(int grp_id)
 
1068
{
 
1069
    Integer agrp_id = (Integer)grp_id;
 
1070
    return (int)wnga_pgroup_nnodes(agrp_id);
 
1071
}
 
1072
 
 
1073
int NGA_Pgroup_nnodes(int grp_id)
 
1074
{
 
1075
    Integer agrp_id = (Integer)grp_id;
 
1076
    return (int)wnga_pgroup_nnodes(agrp_id);
 
1077
}
 
1078
 
 
1079
int GA_Pgroup_create(int *list, int count)
 
1080
{
 
1081
    Integer acount = (Integer)count;
 
1082
    int i;
 
1083
    int grp_id;
 
1084
    Integer *_ga_map_capi;
 
1085
    _ga_map_capi = (Integer*)malloc(count * sizeof(Integer));
 
1086
    for (i=0; i<count; i++)
 
1087
       _ga_map_capi[i] = (Integer)list[i];
 
1088
    grp_id = (int)wnga_pgroup_create(_ga_map_capi,acount);
 
1089
    free(_ga_map_capi);
 
1090
    return grp_id;
 
1091
}
 
1092
 
 
1093
int NGA_Pgroup_create(int *list, int count)
 
1094
{
 
1095
    Integer acount = (Integer)count;
 
1096
    int i;
 
1097
    int grp_id;
 
1098
    Integer *_ga_map_capi;
 
1099
    _ga_map_capi = (Integer*)malloc(count * sizeof(Integer));
 
1100
    for (i=0; i<count; i++)
 
1101
       _ga_map_capi[i] = (Integer)list[i];
 
1102
    grp_id = (int)wnga_pgroup_create(_ga_map_capi,acount);
 
1103
    free(_ga_map_capi);
 
1104
    return grp_id;
 
1105
}
 
1106
 
 
1107
int GA_Pgroup_destroy(int grp)
 
1108
{
 
1109
    Integer grp_id = (Integer)grp;
 
1110
    return (int)wnga_pgroup_destroy(grp_id);
 
1111
}
 
1112
 
 
1113
int NGA_Pgroup_destroy(int grp)
 
1114
{
 
1115
    Integer grp_id = (Integer)grp;
 
1116
    return (int)wnga_pgroup_destroy(grp_id);
 
1117
}
 
1118
 
 
1119
int GA_Pgroup_split(int grp_id, int num_group)
 
1120
{
 
1121
    Integer anum = (Integer)num_group;
 
1122
    Integer grp  = (Integer)grp_id;
 
1123
    return (int)wnga_pgroup_split(grp, anum);
 
1124
}
 
1125
 
 
1126
int NGA_Pgroup_split(int grp_id, int num_group)
 
1127
{
 
1128
    Integer anum = (Integer)num_group;
 
1129
    Integer grp  = (Integer)grp_id;
 
1130
    return (int)wnga_pgroup_split(grp, anum);
 
1131
}
 
1132
 
 
1133
int GA_Pgroup_split_irreg(int grp_id, int color)
 
1134
{
 
1135
    Integer acolor = (Integer)color;
 
1136
    Integer grp  = (Integer)grp_id;
 
1137
    return (int)wnga_pgroup_split_irreg(grp, acolor);
 
1138
}
 
1139
 
 
1140
int NGA_Pgroup_split_irreg(int grp_id, int color)
 
1141
{
 
1142
    Integer acolor = (Integer)color;
 
1143
    Integer grp  = (Integer)grp_id;
 
1144
    return (int)wnga_pgroup_split_irreg(grp, acolor);
 
1145
}
 
1146
 
 
1147
void GA_Update_ghosts(int g_a)
 
1148
{
 
1149
    Integer a=(Integer)g_a;
 
1150
    wnga_update_ghosts(a);
 
1151
}
 
1152
 
 
1153
void NGA_Update_ghosts(int g_a)
 
1154
{
 
1155
    Integer a=(Integer)g_a;
 
1156
    wnga_update_ghosts(a);
 
1157
}
 
1158
 
 
1159
void NGA_Update_ghosts_nb(int g_a, ga_nbhdl_t *nbhandle)
 
1160
{
 
1161
    Integer a=(Integer)g_a;
 
1162
    wnga_update_ghosts_nb(a,nbhandle);
 
1163
}
 
1164
 
 
1165
void GA_Merge_mirrored(int g_a)
 
1166
{
 
1167
    Integer a=(Integer)g_a;
 
1168
    wnga_merge_mirrored(a);
 
1169
}
 
1170
 
 
1171
void NGA_Merge_mirrored(int g_a)
 
1172
{
 
1173
    Integer a=(Integer)g_a;
 
1174
    wnga_merge_mirrored(a);
 
1175
}
 
1176
 
 
1177
void GA_Nblock(int g_a, int *nblock)
 
1178
{
 
1179
    Integer aa, ndim;
 
1180
    Integer _ga_work[MAXDIM];
 
1181
    aa = (Integer)g_a;
 
1182
    wnga_nblock(aa, _ga_work);
 
1183
    ndim = wnga_get_dimension(aa);
 
1184
    COPYF2C(_ga_work,nblock,ndim);
 
1185
}
 
1186
 
 
1187
void NGA_Nblock(int g_a, int *nblock)
 
1188
{
 
1189
    Integer aa, ndim;
 
1190
    Integer _ga_work[MAXDIM];
 
1191
    aa = (Integer)g_a;
 
1192
    wnga_nblock(aa, _ga_work);
 
1193
    ndim = wnga_get_dimension(aa);
 
1194
    COPYF2C(_ga_work,nblock,ndim);
 
1195
}
 
1196
 
 
1197
int GA_Is_mirrored(int g_a)
 
1198
{
 
1199
    Integer a=(Integer)g_a;
 
1200
    return (int)wnga_is_mirrored(a);
 
1201
}
 
1202
 
 
1203
int NGA_Is_mirrored(int g_a)
 
1204
{
 
1205
    Integer a=(Integer)g_a;
 
1206
    return (int)wnga_is_mirrored(a);
 
1207
}
 
1208
 
 
1209
void GA_List_nodeid(int *nlist, int nprocs)
 
1210
{
 
1211
  Integer i, procs;
 
1212
  Integer *list;
 
1213
  procs = (Integer)(nprocs);
 
1214
  list = malloc(procs*sizeof(int));
 
1215
  wnga_list_nodeid(list, procs);
 
1216
  for (i=0; i<procs; i++) {
 
1217
    nlist[i] = (int)list[i];
 
1218
  }
 
1219
  free(list);
 
1220
}
 
1221
 
 
1222
void NGA_List_nodeid(int *nlist, int nprocs)
 
1223
{
 
1224
  Integer i, procs;
 
1225
  Integer *list;
 
1226
  procs = (Integer)(nprocs);
 
1227
  list = malloc(procs*sizeof(int));
 
1228
  wnga_list_nodeid(list, procs);
 
1229
  for (i=0; i<procs; i++) {
 
1230
    nlist[i] = (int)list[i];
 
1231
  }
 
1232
  free(list);
 
1233
}
 
1234
 
 
1235
void NGA_Merge_distr_patch(int g_a, int *alo, int *ahi,
 
1236
                          int g_b, int *blo, int *bhi)
 
1237
{
 
1238
    Integer a = (Integer)g_a;
 
1239
    Integer andim = wnga_ndim(a);
 
1240
 
 
1241
    Integer b=(Integer)g_b;
 
1242
    Integer bndim = wnga_ndim(b);
 
1243
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
1244
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
1245
    
 
1246
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
1247
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
1248
    
 
1249
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
1250
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
1251
 
 
1252
    wnga_merge_distr_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi);
 
1253
}
 
1254
 
 
1255
void NGA_Merge_distr_patch64(int g_a, int64_t *alo, int64_t *ahi,
 
1256
                             int g_b, int64_t *blo, int64_t *bhi)
 
1257
{
 
1258
    Integer a = (Integer)g_a;
 
1259
    Integer andim = wnga_ndim(a);
 
1260
 
 
1261
    Integer b=(Integer)g_b;
 
1262
    Integer bndim = wnga_ndim(b);
 
1263
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
1264
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
1265
    
 
1266
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
1267
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
1268
    
 
1269
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
1270
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
1271
 
 
1272
    wnga_merge_distr_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi);
 
1273
}
 
1274
 
 
1275
int NGA_Update_ghost_dir(int g_a, int dimension, int dir, int flag)
 
1276
{
 
1277
    Integer a=(Integer)g_a;
 
1278
    Integer idim = (Integer)dimension;
 
1279
    Integer idir = (Integer)dir;
 
1280
    logical iflag = (logical)flag;
 
1281
    logical st;
 
1282
    idim++;
 
1283
    st = wnga_update_ghost_dir(a,idim,idir,iflag);
 
1284
    return (int)st;
 
1285
}
 
1286
 
 
1287
void NGA_NbGet_ghost_dir(int g_a, int mask[], ga_nbhdl_t* nbhandle)
 
1288
{
 
1289
    Integer a=(Integer)g_a;
 
1290
    Integer ndim = wnga_ndim(a);
 
1291
    Integer _ga_lo[MAXDIM];
 
1292
    COPYINDEX_C2F(mask,_ga_lo, ndim);
 
1293
    wnga_nbget_ghost_dir(a, _ga_lo,(Integer *)nbhandle);
 
1294
}
 
1295
 
 
1296
void NGA_NbGet_ghost_dir64(int g_a, int64_t mask[], ga_nbhdl_t* nbhandle)
 
1297
{
 
1298
    Integer a=(Integer)g_a;
 
1299
    Integer ndim = wnga_ndim(a);
 
1300
    Integer _ga_lo[MAXDIM];
 
1301
    COPYINDEX_C2F(mask,_ga_lo, ndim);
 
1302
    wnga_nbget_ghost_dir(a, _ga_lo,(Integer *)nbhandle);
 
1303
}
 
1304
 
 
1305
int GA_Has_ghosts(int g_a)
 
1306
{
 
1307
    Integer a=(Integer)g_a;
 
1308
    logical st;
 
1309
    st = wnga_has_ghosts(a);
 
1310
    return (int)st;
 
1311
}
 
1312
 
 
1313
int NGA_Has_ghosts(int g_a)
 
1314
{
 
1315
    Integer a=(Integer)g_a;
 
1316
    logical st;
 
1317
    st = wnga_has_ghosts(a);
 
1318
    return (int)st;
 
1319
}
 
1320
 
 
1321
void NGA_Get_ghost_block(int g_a, int lo[], int hi[], void *buf, int ld[])
 
1322
{
 
1323
    Integer a=(Integer)g_a;
 
1324
    Integer ndim = wnga_ndim(a);
 
1325
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1326
    Integer _ga_work[MAXDIM];
 
1327
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1328
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1329
    COPYC2F(ld,_ga_work, ndim-1);
 
1330
    wnga_get_ghost_block(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1331
}
 
1332
 
 
1333
void NGA_Get_ghost_block64(int g_a, int64_t lo[], int64_t hi[],
 
1334
    void *buf, int64_t ld[])
 
1335
{
 
1336
    Integer a=(Integer)g_a;
 
1337
    Integer ndim = wnga_ndim(a);
 
1338
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1339
    Integer _ga_work[MAXDIM];
 
1340
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1341
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1342
    COPYC2F(ld,_ga_work, ndim-1);
 
1343
    wnga_get_ghost_block(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1344
}
 
1345
 
 
1346
void GA_Mask_sync(int first, int last)
 
1347
{
 
1348
    Integer ifirst = (Integer)first;
 
1349
    Integer ilast = (Integer)last;
 
1350
    wnga_mask_sync(ifirst,ilast);
 
1351
}
 
1352
 
 
1353
void NGA_Mask_sync(int first, int last)
 
1354
{
 
1355
    Integer ifirst = (Integer)first;
 
1356
    Integer ilast = (Integer)last;
 
1357
    wnga_mask_sync(ifirst,ilast);
 
1358
}
 
1359
 
 
1360
int GA_Duplicate(int g_a, char* array_name)
 
1361
{
 
1362
    logical st;
 
1363
    Integer a=(Integer)g_a, b;
 
1364
    st = wnga_duplicate(a, &b, array_name);
 
1365
    if(st==TRUE) return (int) b;
 
1366
    else return 0;
 
1367
}
 
1368
 
 
1369
int NGA_Duplicate(int g_a, char* array_name)
 
1370
{
 
1371
    logical st;
 
1372
    Integer a=(Integer)g_a, b;
 
1373
    st = wnga_duplicate(a, &b, array_name);
 
1374
    if(st==TRUE) return (int) b;
 
1375
    else return 0;
 
1376
}
 
1377
 
 
1378
void GA_Destroy(int g_a)
 
1379
{
 
1380
    logical st;
 
1381
    Integer a=(Integer)g_a;
 
1382
    st = wnga_destroy(a);
 
1383
    if(st==FALSE)GA_Error("GA (c) destroy failed",g_a);
 
1384
}
 
1385
 
 
1386
void NGA_Destroy(int g_a)
 
1387
{
 
1388
    logical st;
 
1389
    Integer a=(Integer)g_a;
 
1390
    st = wnga_destroy(a);
 
1391
    if(st==FALSE)GA_Error("GA (c) destroy failed",g_a);
 
1392
}
 
1393
 
 
1394
void GA_Set_memory_limit(size_t limit)
 
1395
{
 
1396
Integer lim = (Integer)limit;
 
1397
     wnga_set_memory_limit(lim);
 
1398
}
 
1399
 
 
1400
void NGA_Set_memory_limit(size_t limit)
 
1401
{
 
1402
Integer lim = (Integer)limit;
 
1403
     wnga_set_memory_limit(lim);
 
1404
}
 
1405
 
 
1406
void GA_Zero(int g_a)
 
1407
{
 
1408
    Integer a=(Integer)g_a;
 
1409
    wnga_zero(a);
 
1410
}
 
1411
 
 
1412
void NGA_Zero(int g_a)
 
1413
{
 
1414
    Integer a=(Integer)g_a;
 
1415
    wnga_zero(a);
 
1416
}
 
1417
 
 
1418
int GA_Pgroup_get_default()
 
1419
{
 
1420
    int value = (int)wnga_pgroup_get_default();
 
1421
    return value;
 
1422
}
 
1423
 
 
1424
int NGA_Pgroup_get_default()
 
1425
{
 
1426
    int value = (int)wnga_pgroup_get_default();
 
1427
    return value;
 
1428
}
 
1429
 
 
1430
void GA_Pgroup_set_default(int p_handle)
 
1431
{
 
1432
    Integer grp = (Integer)p_handle;
 
1433
    wnga_pgroup_set_default(grp);
 
1434
}
 
1435
 
 
1436
void NGA_Pgroup_set_default(int p_handle)
 
1437
{
 
1438
    Integer grp = (Integer)p_handle;
 
1439
    wnga_pgroup_set_default(grp);
 
1440
}
 
1441
 
 
1442
int GA_Pgroup_get_mirror()
 
1443
{
 
1444
    int value = (int)wnga_pgroup_get_mirror();
 
1445
    return value;
 
1446
}
 
1447
 
 
1448
int NGA_Pgroup_get_mirror()
 
1449
{
 
1450
    int value = (int)wnga_pgroup_get_mirror();
 
1451
    return value;
 
1452
}
 
1453
 
 
1454
int GA_Pgroup_get_world()
 
1455
{
 
1456
    int value = (int)wnga_pgroup_get_world();
 
1457
    return value;
 
1458
}
 
1459
 
 
1460
int NGA_Pgroup_get_world()
 
1461
{
 
1462
    int value = (int)wnga_pgroup_get_world();
 
1463
    return value;
 
1464
}
 
1465
 
 
1466
int GA_Idot(int g_a, int g_b)
 
1467
{
 
1468
    int value;
 
1469
    Integer a=(Integer)g_a;
 
1470
    Integer b=(Integer)g_b;
 
1471
    wnga_dot(C_INT, a, b, &value);
 
1472
    return value;
 
1473
}
 
1474
 
 
1475
 
 
1476
long GA_Ldot(int g_a, int g_b)
 
1477
{
 
1478
    long value;
 
1479
    Integer a=(Integer)g_a;
 
1480
    Integer b=(Integer)g_b;
 
1481
    wnga_dot(C_LONG, a, b, &value);
 
1482
    return value;
 
1483
}
 
1484
 
 
1485
 
 
1486
long long GA_Lldot(int g_a, int g_b)
 
1487
{
 
1488
    long long value;
 
1489
    Integer a=(Integer)g_a;
 
1490
    Integer b=(Integer)g_b;
 
1491
    wnga_dot(C_LONGLONG, a, b, &value);
 
1492
    return value;
 
1493
}
 
1494
 
 
1495
     
 
1496
double GA_Ddot(int g_a, int g_b)
 
1497
{
 
1498
    double value;
 
1499
    Integer a=(Integer)g_a;
 
1500
    Integer b=(Integer)g_b;
 
1501
    wnga_dot(C_DBL, a, b, &value);
 
1502
    return value;
 
1503
}
 
1504
 
 
1505
 
 
1506
DoubleComplex GA_Zdot(int g_a, int g_b)
 
1507
{
 
1508
    DoubleComplex value;
 
1509
    Integer a=(Integer)g_a;
 
1510
    Integer b=(Integer)g_b;
 
1511
    wnga_dot(pnga_type_f2c(MT_F_DCPL),a,b,&value);
 
1512
    return value;
 
1513
}
 
1514
 
 
1515
 
 
1516
SingleComplex GA_Cdot(int g_a, int g_b)
 
1517
{
 
1518
    SingleComplex value;
 
1519
    Integer a=(Integer)g_a;
 
1520
    Integer b=(Integer)g_b;
 
1521
    wnga_dot(pnga_type_f2c(MT_F_SCPL),a,b,&value);
 
1522
    return value;
 
1523
}
 
1524
 
 
1525
 
 
1526
float GA_Fdot(int g_a, int g_b)
 
1527
{
 
1528
    float sum;
 
1529
    Integer a=(Integer)g_a;
 
1530
    Integer b=(Integer)g_b;
 
1531
    wnga_dot(C_FLOAT, a, b, &sum);
 
1532
    return sum;
 
1533
}    
 
1534
 
 
1535
 
 
1536
void GA_Randomize(int g_a, void *value)
 
1537
{
 
1538
    Integer a=(Integer)g_a;
 
1539
    wnga_randomize(a, value);
 
1540
}
 
1541
 
 
1542
void NGA_Randomize(int g_a, void *value)
 
1543
{
 
1544
    Integer a=(Integer)g_a;
 
1545
    wnga_randomize(a, value);
 
1546
}
 
1547
 
 
1548
void GA_Fill(int g_a, void *value)
 
1549
{
 
1550
    Integer a=(Integer)g_a;
 
1551
    wnga_fill(a, value);
 
1552
}
 
1553
 
 
1554
void NGA_Fill(int g_a, void *value)
 
1555
{
 
1556
    Integer a=(Integer)g_a;
 
1557
    wnga_fill(a, value);
 
1558
}
 
1559
 
 
1560
void GA_Scale(int g_a, void *value)
 
1561
{
 
1562
    Integer a=(Integer)g_a;
 
1563
    wnga_scale(a,value);
 
1564
}
 
1565
 
 
1566
 
 
1567
void GA_Add(void *alpha, int g_a, void* beta, int g_b, int g_c)
 
1568
{
 
1569
    Integer a=(Integer)g_a;
 
1570
    Integer b=(Integer)g_b;
 
1571
    Integer c=(Integer)g_c;
 
1572
    wnga_add(alpha, a, beta, b, c);
 
1573
}
 
1574
 
 
1575
 
 
1576
void GA_Copy(int g_a, int g_b)
 
1577
{
 
1578
    Integer a=(Integer)g_a;
 
1579
    Integer b=(Integer)g_b;
 
1580
    wnga_copy(a, b);
 
1581
}
 
1582
 
 
1583
 
 
1584
void NGA_Get(int g_a, int lo[], int hi[], void* buf, int ld[])
 
1585
{
 
1586
    Integer a=(Integer)g_a;
 
1587
    Integer ndim = wnga_ndim(a);
 
1588
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1589
    Integer _ga_work[MAXDIM];
 
1590
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1591
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1592
    COPYC2F(ld,_ga_work, ndim-1);
 
1593
    wnga_get(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1594
}
 
1595
 
 
1596
void NGA_Get64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[])
 
1597
{
 
1598
    Integer a=(Integer)g_a;
 
1599
    Integer ndim = wnga_ndim(a);
 
1600
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1601
    Integer _ga_work[MAXDIM];
 
1602
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1603
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1604
    COPYC2F(ld,_ga_work, ndim-1);
 
1605
    wnga_get(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1606
}
 
1607
 
 
1608
void NGA_NbGet(int g_a, int lo[], int hi[], void* buf, int ld[],
 
1609
               ga_nbhdl_t* nbhandle)
 
1610
{
 
1611
    Integer a=(Integer)g_a;
 
1612
    Integer ndim = wnga_ndim(a);
 
1613
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1614
    Integer _ga_work[MAXDIM];
 
1615
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1616
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1617
    COPYC2F(ld,_ga_work, ndim-1);
 
1618
    wnga_nbget(a, _ga_lo, _ga_hi, buf, _ga_work,(Integer *)nbhandle);
 
1619
}
 
1620
 
 
1621
void NGA_NbGet64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[],
 
1622
               ga_nbhdl_t* nbhandle)
 
1623
{
 
1624
    Integer a=(Integer)g_a;
 
1625
    Integer ndim = wnga_ndim(a);
 
1626
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1627
    Integer _ga_work[MAXDIM];
 
1628
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1629
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1630
    COPYC2F(ld,_ga_work, ndim-1);
 
1631
    wnga_nbget(a, _ga_lo, _ga_hi, buf, _ga_work,(Integer *)nbhandle);
 
1632
}
 
1633
 
 
1634
void NGA_Put(int g_a, int lo[], int hi[], void* buf, int ld[])
 
1635
{
 
1636
    Integer a=(Integer)g_a;
 
1637
    Integer ndim = wnga_ndim(a);
 
1638
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1639
    Integer _ga_work[MAXDIM];
 
1640
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1641
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1642
    COPYC2F(ld,_ga_work, ndim-1);
 
1643
    wnga_put(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1644
}    
 
1645
 
 
1646
void NGA_Put64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[])
 
1647
{
 
1648
    Integer a=(Integer)g_a;
 
1649
    Integer ndim = wnga_ndim(a);
 
1650
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1651
    Integer _ga_work[MAXDIM];
 
1652
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1653
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1654
    COPYC2F(ld,_ga_work, ndim-1);
 
1655
    wnga_put(a, _ga_lo, _ga_hi, buf, _ga_work);
 
1656
}    
 
1657
 
 
1658
void NGA_NbPut(int g_a, int lo[], int hi[], void* buf, int ld[],
 
1659
               ga_nbhdl_t* nbhandle)
 
1660
{
 
1661
    Integer a=(Integer)g_a;
 
1662
    Integer ndim = wnga_ndim(a);
 
1663
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1664
    Integer _ga_work[MAXDIM];
 
1665
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1666
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1667
    COPYC2F(ld,_ga_work, ndim-1);
 
1668
    wnga_nbput(a, _ga_lo, _ga_hi, buf, _ga_work,(Integer *)nbhandle);
 
1669
}
 
1670
 
 
1671
void NGA_NbPut64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[],
 
1672
                 ga_nbhdl_t* nbhandle)
 
1673
{
 
1674
    Integer a=(Integer)g_a;
 
1675
    Integer ndim = wnga_ndim(a);
 
1676
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1677
    Integer _ga_work[MAXDIM];
 
1678
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1679
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1680
    COPYC2F(ld,_ga_work, ndim-1);
 
1681
    wnga_nbput(a, _ga_lo, _ga_hi, buf, _ga_work,(Integer *)nbhandle);
 
1682
}
 
1683
 
 
1684
int NGA_NbTest(ga_nbhdl_t* nbhandle)
 
1685
{
 
1686
    return(wnga_nbtest((Integer *)nbhandle));
 
1687
}
 
1688
 
 
1689
void NGA_NbWait(ga_nbhdl_t* nbhandle)
 
1690
{
 
1691
    wnga_nbwait((Integer *)nbhandle);
 
1692
}
 
1693
 
 
1694
void NGA_Strided_acc(int g_a, int lo[], int hi[], int skip[],
 
1695
                     void* buf, int ld[], void *alpha)
 
1696
{
 
1697
    Integer a=(Integer)g_a;
 
1698
    Integer ndim = wnga_ndim(a);
 
1699
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM], _ga_skip[MAXDIM];
 
1700
    Integer _ga_work[MAXDIM];
 
1701
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1702
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1703
    COPYC2F(ld,_ga_work, ndim-1);
 
1704
    COPYC2F(skip, _ga_skip, ndim);
 
1705
    wnga_strided_acc(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work, alpha);
 
1706
}    
 
1707
 
 
1708
void NGA_Strided_acc64(int g_a, int64_t lo[], int64_t hi[], int64_t skip[],
 
1709
                     void* buf, int64_t ld[], void *alpha)
 
1710
{
 
1711
    Integer a=(Integer)g_a;
 
1712
    Integer ndim = wnga_ndim(a);
 
1713
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1714
    Integer _ga_skip[MAXDIM];
 
1715
    Integer _ga_work[MAXDIM];
 
1716
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1717
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1718
    COPYC2F(ld,_ga_work, ndim-1);
 
1719
    COPYC2F(skip, _ga_skip, ndim);
 
1720
    wnga_strided_acc(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work, alpha);
 
1721
}
 
1722
 
 
1723
void NGA_Strided_get(int g_a, int lo[], int hi[], int skip[],
 
1724
                     void* buf, int ld[])
 
1725
{
 
1726
    Integer a=(Integer)g_a;
 
1727
    Integer ndim = wnga_ndim(a);
 
1728
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1729
    Integer _ga_skip[MAXDIM];
 
1730
    Integer _ga_work[MAXDIM];
 
1731
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1732
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1733
    COPYC2F(ld,_ga_work, ndim-1);
 
1734
    COPYC2F(skip, _ga_skip, ndim);
 
1735
    wnga_strided_get(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work);
 
1736
}    
 
1737
 
 
1738
void NGA_Strided_get64(int g_a, int64_t lo[], int64_t hi[], int64_t skip[],
 
1739
                     void* buf, int64_t ld[])
 
1740
{
 
1741
    Integer a=(Integer)g_a;
 
1742
    Integer ndim = wnga_ndim(a);
 
1743
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1744
    Integer _ga_skip[MAXDIM];
 
1745
    Integer _ga_work[MAXDIM];
 
1746
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1747
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1748
    COPYC2F(ld,_ga_work, ndim-1);
 
1749
    COPYC2F(skip, _ga_skip, ndim);
 
1750
    wnga_strided_get(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work);
 
1751
}
 
1752
 
 
1753
void NGA_Strided_put(int g_a, int lo[], int hi[], int skip[],
 
1754
                     void* buf, int ld[])
 
1755
{
 
1756
    Integer a=(Integer)g_a;
 
1757
    Integer ndim = wnga_ndim(a);
 
1758
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1759
    Integer _ga_skip[MAXDIM];
 
1760
    Integer _ga_work[MAXDIM];
 
1761
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1762
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1763
    COPYC2F(ld,_ga_work, ndim-1);
 
1764
    COPYC2F(skip, _ga_skip, ndim);
 
1765
    wnga_strided_put(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work);
 
1766
}    
 
1767
 
 
1768
void NGA_Strided_put64(int g_a, int64_t lo[], int64_t hi[], int64_t skip[],
 
1769
                     void* buf, int64_t ld[])
 
1770
{
 
1771
    Integer a=(Integer)g_a;
 
1772
    Integer ndim = wnga_ndim(a);
 
1773
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1774
    Integer _ga_skip[MAXDIM];
 
1775
    Integer _ga_work[MAXDIM];
 
1776
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1777
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1778
    COPYC2F(ld,_ga_work, ndim-1);
 
1779
    COPYC2F(skip, _ga_skip, ndim);
 
1780
    wnga_strided_put(a, _ga_lo, _ga_hi, _ga_skip, buf, _ga_work);
 
1781
}
 
1782
 
 
1783
void NGA_Acc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha)
 
1784
{
 
1785
    Integer a=(Integer)g_a;
 
1786
    Integer ndim = wnga_ndim(a);
 
1787
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1788
    Integer _ga_work[MAXDIM];
 
1789
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1790
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1791
    COPYC2F(ld,_ga_work, ndim-1);
 
1792
    wnga_acc(a, _ga_lo, _ga_hi, buf, _ga_work, alpha);
 
1793
}    
 
1794
 
 
1795
void NGA_Acc64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[], void* alpha)
 
1796
{
 
1797
    Integer a=(Integer)g_a;
 
1798
    Integer ndim = wnga_ndim(a);
 
1799
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1800
    Integer _ga_work[MAXDIM];
 
1801
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1802
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1803
    COPYC2F(ld,_ga_work, ndim-1);
 
1804
    wnga_acc(a, _ga_lo, _ga_hi, buf, _ga_work, alpha);
 
1805
}    
 
1806
 
 
1807
void NGA_NbAcc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha,
 
1808
               ga_nbhdl_t* nbhandle)
 
1809
{
 
1810
    Integer a=(Integer)g_a;
 
1811
    Integer ndim = wnga_ndim(a);
 
1812
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1813
    Integer _ga_work[MAXDIM];
 
1814
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1815
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1816
    COPYC2F(ld,_ga_work, ndim-1);
 
1817
    wnga_nbacc(a, _ga_lo,_ga_hi,buf,_ga_work,alpha,(Integer *)nbhandle);
 
1818
}
 
1819
 
 
1820
void NGA_NbAcc64(int g_a, int64_t lo[], int64_t hi[], void* buf,int64_t ld[], void* alpha,
 
1821
               ga_nbhdl_t* nbhandle)
 
1822
{
 
1823
    Integer a=(Integer)g_a;
 
1824
    Integer ndim = wnga_ndim(a);
 
1825
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1826
    Integer _ga_work[MAXDIM];
 
1827
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1828
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1829
    COPYC2F(ld,_ga_work, ndim-1);
 
1830
    wnga_nbacc(a, _ga_lo,_ga_hi,buf,_ga_work,alpha,(Integer *)nbhandle);
 
1831
}
 
1832
 
 
1833
void NGA_Periodic_get(int g_a, int lo[], int hi[], void* buf, int ld[])
 
1834
{
 
1835
    Integer a=(Integer)g_a;
 
1836
    Integer ndim = wnga_ndim(a);
 
1837
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1838
    Integer _ga_work[MAXDIM];
 
1839
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1840
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1841
    COPYC2F(ld,_ga_work, ndim-1);
 
1842
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, NULL, PERIODIC_GET);
 
1843
}
 
1844
 
 
1845
void NGA_Periodic_get64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[])
 
1846
{
 
1847
    Integer a=(Integer)g_a;
 
1848
    Integer ndim = wnga_ndim(a);
 
1849
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1850
    Integer _ga_work[MAXDIM];
 
1851
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1852
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1853
    COPYC2F(ld,_ga_work, ndim-1);
 
1854
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, NULL, PERIODIC_GET);
 
1855
}
 
1856
 
 
1857
void NGA_Periodic_put(int g_a, int lo[], int hi[], void* buf, int ld[])
 
1858
{
 
1859
    Integer a=(Integer)g_a;
 
1860
    Integer ndim = wnga_ndim(a);
 
1861
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1862
    Integer _ga_work[MAXDIM];
 
1863
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1864
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1865
    COPYC2F(ld,_ga_work, ndim-1);
 
1866
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, NULL, PERIODIC_PUT);
 
1867
}    
 
1868
 
 
1869
void NGA_Periodic_put64(int g_a, int64_t lo[], int64_t hi[], void* buf, int64_t ld[])
 
1870
{
 
1871
    Integer a=(Integer)g_a;
 
1872
    Integer ndim = wnga_ndim(a);
 
1873
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1874
    Integer _ga_work[MAXDIM];
 
1875
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1876
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1877
    COPYC2F(ld,_ga_work, ndim-1);
 
1878
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, NULL, PERIODIC_PUT);
 
1879
}
 
1880
 
 
1881
void NGA_Periodic_acc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha)
 
1882
{
 
1883
    Integer a=(Integer)g_a;
 
1884
    Integer ndim = wnga_ndim(a);
 
1885
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1886
    Integer _ga_work[MAXDIM];
 
1887
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1888
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1889
    COPYC2F(ld,_ga_work, ndim-1);
 
1890
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, alpha, PERIODIC_ACC);
 
1891
}
 
1892
 
 
1893
void NGA_Periodic_acc64(int g_a, int64_t lo[], int64_t hi[], void* buf,int64_t ld[], void* alpha)
 
1894
{
 
1895
    Integer a=(Integer)g_a;
 
1896
    Integer ndim = wnga_ndim(a);
 
1897
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1898
    Integer _ga_work[MAXDIM];
 
1899
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
1900
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
1901
    COPYC2F(ld,_ga_work, ndim-1);
 
1902
    wnga_periodic(a, _ga_lo, _ga_hi, buf, _ga_work, alpha, PERIODIC_ACC);
 
1903
}
 
1904
 
 
1905
long NGA_Read_inc(int g_a, int subscript[], long inc)
 
1906
{
 
1907
    Integer a=(Integer)g_a;
 
1908
    Integer ndim = wnga_ndim(a);
 
1909
    Integer in=(Integer)inc;
 
1910
    Integer _ga_lo[MAXDIM];
 
1911
    COPYINDEX_C2F(subscript, _ga_lo, ndim);
 
1912
    return (long)wnga_read_inc(a, _ga_lo, in);
 
1913
}
 
1914
 
 
1915
long NGA_Read_inc64(int g_a, int64_t subscript[], long inc)
 
1916
{
 
1917
    Integer a=(Integer)g_a;
 
1918
    Integer ndim = wnga_ndim(a);
 
1919
    Integer in=(Integer)inc;
 
1920
    Integer _ga_lo[MAXDIM];
 
1921
    COPYINDEX_C2F(subscript, _ga_lo, ndim);
 
1922
    return (long)wnga_read_inc(a, _ga_lo, in);
 
1923
}
 
1924
 
 
1925
void NGA_Distribution(int g_a, int iproc, int lo[], int hi[])
 
1926
{
 
1927
     Integer a=(Integer)g_a;
 
1928
     Integer p=(Integer)iproc;
 
1929
     Integer ndim = wnga_ndim(a);
 
1930
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1931
     wnga_distribution(a, p, _ga_lo, _ga_hi);
 
1932
     COPYINDEX_F2C(_ga_lo,lo, ndim);
 
1933
     COPYINDEX_F2C(_ga_hi,hi, ndim);
 
1934
}
 
1935
 
 
1936
void NGA_Distribution64(int g_a, int iproc, int64_t lo[], int64_t hi[])
 
1937
{
 
1938
     Integer a=(Integer)g_a;
 
1939
     Integer p=(Integer)iproc;
 
1940
     Integer ndim = wnga_ndim(a);
 
1941
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
1942
     wnga_distribution(a, p, _ga_lo, _ga_hi);
 
1943
     COPYINDEX_F2C_64(_ga_lo,lo, ndim);
 
1944
     COPYINDEX_F2C_64(_ga_hi,hi, ndim);
 
1945
}
 
1946
 
 
1947
void NGA_Select_elem(int g_a, char* op, void* val, int* index)
 
1948
{
 
1949
     Integer a=(Integer)g_a;
 
1950
     Integer ndim = wnga_ndim(a);
 
1951
     Integer _ga_lo[MAXDIM];
 
1952
     wnga_select_elem(a, op, val, _ga_lo);
 
1953
     COPYINDEX_F2C(_ga_lo,index,ndim);
 
1954
}
 
1955
 
 
1956
void NGA_Select_elem64(int g_a, char* op, void* val, int64_t* index)
 
1957
{
 
1958
     Integer a=(Integer)g_a;
 
1959
     Integer ndim = wnga_ndim(a);
 
1960
     Integer _ga_lo[MAXDIM];
 
1961
     wnga_select_elem(a, op, val, _ga_lo);
 
1962
     COPYINDEX_F2C_64(_ga_lo,index,ndim);
 
1963
}
 
1964
 
 
1965
void GA_Scan_add(int g_a, int g_b, int g_sbit, int lo,
 
1966
                 int hi, int excl)
 
1967
{
 
1968
     Integer a = (Integer)g_a;
 
1969
     Integer b = (Integer)g_b;
 
1970
     Integer s = (Integer)g_sbit;
 
1971
     Integer x = (Integer)excl;
 
1972
     Integer alo = lo+1;
 
1973
     Integer ahi = hi+1;
 
1974
     wnga_scan_add(a, b, s, alo, ahi, x);
 
1975
 
 
1976
}
 
1977
 
 
1978
void GA_Scan_add64(int g_a, int g_b, int g_sbit, int64_t lo,
 
1979
                 int64_t hi, int excl)
 
1980
{
 
1981
     Integer a = (Integer)g_a;
 
1982
     Integer b = (Integer)g_b;
 
1983
     Integer s = (Integer)g_sbit;
 
1984
     Integer x = (Integer)excl;
 
1985
     Integer alo = lo+1;
 
1986
     Integer ahi = hi+1;
 
1987
     wnga_scan_add(a, b, s, alo, ahi, x);
 
1988
 
 
1989
}
 
1990
 
 
1991
void GA_Scan_copy(int g_a, int g_b, int g_sbit, int lo,
 
1992
                  int hi)
 
1993
{
 
1994
     Integer a = (Integer)g_a;
 
1995
     Integer b = (Integer)g_b;
 
1996
     Integer s = (Integer)g_sbit;
 
1997
     Integer alo = lo+1;
 
1998
     Integer ahi = hi+1;
 
1999
     wnga_scan_copy(a, b, s, alo, ahi);
 
2000
 
 
2001
}
 
2002
 
 
2003
void GA_Scan_copy64(int g_a, int g_b, int g_sbit, int64_t lo,
 
2004
                    int64_t hi)
 
2005
{
 
2006
     Integer a = (Integer)g_a;
 
2007
     Integer b = (Integer)g_b;
 
2008
     Integer s = (Integer)g_sbit;
 
2009
     Integer alo = lo+1;
 
2010
     Integer ahi = hi+1;
 
2011
     wnga_scan_copy(a, b, s, alo, ahi);
 
2012
 
 
2013
}
 
2014
 
 
2015
void GA_Patch_enum(int g_a, int lo, int hi, void *start, void *inc)
 
2016
{
 
2017
     Integer a = (Integer)g_a;
 
2018
     Integer alo = lo+1;
 
2019
     Integer ahi = hi+1;
 
2020
     wnga_patch_enum(a, alo, ahi, start, inc);
 
2021
}
 
2022
 
 
2023
void GA_Patch_enum64(int g_a, int64_t lo, int64_t hi, void *start, void *inc)
 
2024
{
 
2025
     Integer a = (Integer)g_a;
 
2026
     Integer alo = lo+1;
 
2027
     Integer ahi = hi+1;
 
2028
     wnga_patch_enum(a, alo, ahi, start, inc);
 
2029
}
 
2030
 
 
2031
void GA_Pack(int g_src, int g_dest, int g_mask, int lo, int hi, int *icount)
 
2032
{
 
2033
     Integer a = (Integer)g_src;
 
2034
     Integer b = (Integer)g_dest;
 
2035
     Integer s = (Integer)g_mask;
 
2036
     Integer icnt;
 
2037
     Integer alo = lo+1;
 
2038
     Integer ahi = hi+1;
 
2039
     wnga_pack(a, b, s, alo, ahi, &icnt); 
 
2040
     *icount = icnt;
 
2041
}
 
2042
 
 
2043
void GA_Pack64(int g_src, int g_dest, int g_mask, int64_t lo, int64_t hi, int64_t *icount)
 
2044
{
 
2045
     Integer a = (Integer)g_src;
 
2046
     Integer b = (Integer)g_dest;
 
2047
     Integer s = (Integer)g_mask;
 
2048
     Integer icnt;
 
2049
     Integer alo = lo+1;
 
2050
     Integer ahi = hi+1;
 
2051
     wnga_pack(a, b, s, alo, ahi, &icnt); 
 
2052
     *icount = icnt;
 
2053
}
 
2054
 
 
2055
void GA_Unpack(int g_src, int g_dest, int g_mask, int lo, int hi, int *icount)
 
2056
{
 
2057
     Integer a = (Integer)g_src;
 
2058
     Integer b = (Integer)g_dest;
 
2059
     Integer s = (Integer)g_mask;
 
2060
     Integer icnt;
 
2061
     Integer alo = lo+1;
 
2062
     Integer ahi = hi+1;
 
2063
     wnga_unpack(a, b, s, alo, ahi, &icnt); 
 
2064
     *icount = icnt;
 
2065
}
 
2066
 
 
2067
void GA_Unpack64(int g_src, int g_dest, int g_mask, int64_t lo, int64_t hi, int64_t *icount)
 
2068
{
 
2069
     Integer a = (Integer)g_src;
 
2070
     Integer b = (Integer)g_dest;
 
2071
     Integer s = (Integer)g_mask;
 
2072
     Integer icnt;
 
2073
     Integer alo = lo+1;
 
2074
     Integer ahi = hi+1;
 
2075
     wnga_unpack(a, b, s, alo, ahi, &icnt); 
 
2076
     *icount = icnt;
 
2077
}
 
2078
 
 
2079
int GA_Compare_distr(int g_a, int g_b)
 
2080
{
 
2081
    logical st;
 
2082
    Integer a=(Integer)g_a;
 
2083
    Integer b=(Integer)g_b;
 
2084
    st = wnga_compare_distr(a,b);
 
2085
    if(st == TRUE) return 0;
 
2086
    else return 1;
 
2087
}
 
2088
 
 
2089
int NGA_Compare_distr(int g_a, int g_b)
 
2090
{
 
2091
    logical st;
 
2092
    Integer a=(Integer)g_a;
 
2093
    Integer b=(Integer)g_b;
 
2094
    st = wnga_compare_distr(a,b);
 
2095
    if(st == TRUE) return 0;
 
2096
    else return 1;
 
2097
}
 
2098
 
 
2099
void NGA_Access(int g_a, int lo[], int hi[], void *ptr, int ld[])
 
2100
{
 
2101
     Integer a=(Integer)g_a;
 
2102
     Integer ndim = wnga_ndim(a);
 
2103
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2104
     Integer _ga_work[MAXDIM];
 
2105
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2106
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2107
 
 
2108
     wnga_access_ptr(a,_ga_lo, _ga_hi, ptr, _ga_work);
 
2109
     COPYF2C(_ga_work,ld, ndim-1);
 
2110
}
 
2111
 
 
2112
void NGA_Access64(int g_a, int64_t lo[], int64_t hi[], void *ptr, int64_t ld[])
 
2113
{
 
2114
     Integer a=(Integer)g_a;
 
2115
     Integer ndim = wnga_ndim(a);
 
2116
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2117
     Integer _ga_work[MAXDIM];
 
2118
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2119
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2120
 
 
2121
     wnga_access_ptr(a,_ga_lo, _ga_hi, ptr, _ga_work);
 
2122
     COPYF2C_64(_ga_work,ld, ndim-1);
 
2123
}
 
2124
 
 
2125
void NGA_Access_block(int g_a, int idx, void *ptr, int ld[])
 
2126
{
 
2127
     Integer a=(Integer)g_a;
 
2128
     Integer ndim = wnga_ndim(a);
 
2129
     Integer iblock = (Integer)idx;
 
2130
     Integer _ga_work[MAXDIM];
 
2131
     wnga_access_block_ptr(a,iblock,ptr,_ga_work);
 
2132
     COPYF2C(_ga_work,ld, ndim-1);
 
2133
}
 
2134
 
 
2135
void NGA_Access_block64(int g_a, int64_t idx, void *ptr, int64_t ld[])
 
2136
{
 
2137
     Integer a=(Integer)g_a;
 
2138
     Integer ndim = wnga_ndim(a);
 
2139
     Integer iblock = (Integer)idx;
 
2140
     Integer _ga_work[MAXDIM];
 
2141
     wnga_access_block_ptr(a,iblock,ptr,_ga_work);
 
2142
     COPYF2C_64(_ga_work,ld, ndim-1);
 
2143
}
 
2144
 
 
2145
void NGA_Access_block_grid(int g_a, int index[], void *ptr, int ld[])
 
2146
{
 
2147
     Integer a=(Integer)g_a;
 
2148
     Integer ndim = wnga_ndim(a);
 
2149
     Integer _ga_work[MAXDIM], _ga_lo[MAXDIM];
 
2150
     COPYC2F(index, _ga_lo, ndim);
 
2151
     wnga_access_block_grid_ptr(a,_ga_lo,ptr,_ga_work);
 
2152
     COPYF2C(_ga_work,ld, ndim-1);
 
2153
}
 
2154
 
 
2155
void NGA_Access_block_grid64(int g_a, int64_t index[], void *ptr, int64_t ld[])
 
2156
{
 
2157
     Integer a=(Integer)g_a;
 
2158
     Integer ndim = wnga_ndim(a);
 
2159
     Integer _ga_lo[MAXDIM], _ga_work[MAXDIM];
 
2160
     COPYC2F(index, _ga_lo, ndim);
 
2161
     wnga_access_block_grid_ptr(a,_ga_lo,ptr,_ga_work);
 
2162
     COPYF2C_64(_ga_work,ld, ndim-1);
 
2163
}
 
2164
 
 
2165
void NGA_Access_block_segment(int g_a, int proc, void *ptr, int *len)
 
2166
{
 
2167
     Integer a=(Integer)g_a;
 
2168
     Integer iblock = (Integer)proc;
 
2169
     Integer ilen = (Integer)(*len);
 
2170
     wnga_access_block_segment_ptr(a,iblock,ptr,&ilen);
 
2171
     *len = (int)ilen;
 
2172
}
 
2173
 
 
2174
void NGA_Access_block_segment64(int g_a, int proc, void *ptr, int64_t *len)
 
2175
{
 
2176
     Integer a=(Integer)g_a;
 
2177
     Integer iblock = (Integer)proc;
 
2178
     Integer ilen = (Integer)(*len);
 
2179
     wnga_access_block_segment_ptr(a,iblock,ptr,&ilen);
 
2180
     *len = (int64_t)ilen;
 
2181
}
 
2182
 
 
2183
void NGA_Access_ghosts(int g_a, int dims[], void *ptr, int ld[])
 
2184
{
 
2185
     Integer a=(Integer)g_a;
 
2186
     Integer ndim = wnga_ndim(a);
 
2187
     Integer _ga_lo[MAXDIM];
 
2188
     Integer _ga_work[MAXDIM];
 
2189
     wnga_access_ghost_ptr(a, _ga_lo, ptr, _ga_work);
 
2190
     COPYF2C(_ga_work,ld, ndim-1);
 
2191
     COPYF2C(_ga_lo, dims, ndim);
 
2192
}
 
2193
 
 
2194
void NGA_Access_ghosts64(int g_a, int64_t dims[], void *ptr, int64_t ld[])
 
2195
{
 
2196
     Integer a=(Integer)g_a;
 
2197
     Integer ndim = wnga_ndim(a);
 
2198
     Integer _ga_lo[MAXDIM];
 
2199
     Integer _ga_work[MAXDIM];
 
2200
 
 
2201
     wnga_access_ghost_ptr(a, _ga_lo, ptr, _ga_work);
 
2202
     COPYF2C_64(_ga_work,ld, ndim-1);
 
2203
     COPYF2C_64(_ga_lo, dims, ndim);
 
2204
}
 
2205
 
 
2206
void NGA_Access_ghost_element(int g_a, void *ptr, int subscript[], int ld[])
 
2207
{
 
2208
     Integer a=(Integer)g_a;
 
2209
     Integer ndim = wnga_ndim(a);
 
2210
     Integer _subscript[MAXDIM];
 
2211
     Integer _ld[MAXDIM];
 
2212
 
 
2213
     COPYINDEX_C2F(subscript, _subscript, ndim);
 
2214
     COPYINDEX_C2F(ld, _ld, ndim-1);
 
2215
     wnga_access_ghost_element_ptr(a, ptr, _subscript, _ld);
 
2216
}
 
2217
 
 
2218
void NGA_Access_ghost_element64(int g_a, void *ptr, int64_t subscript[], int64_t ld[])
 
2219
{
 
2220
     Integer a=(Integer)g_a;
 
2221
     Integer ndim = wnga_ndim(a);
 
2222
     Integer _subscript[MAXDIM];
 
2223
     Integer _ld[MAXDIM];
 
2224
 
 
2225
     COPYINDEX_C2F(subscript, _subscript, ndim);
 
2226
     COPYINDEX_C2F(ld, _ld, ndim-1);
 
2227
     wnga_access_ghost_element_ptr(a, ptr, _subscript, _ld);
 
2228
}
 
2229
 
 
2230
void NGA_Release(int g_a, int lo[], int hi[])
 
2231
{
 
2232
     Integer a=(Integer)g_a;
 
2233
     Integer ndim = wnga_ndim(a);
 
2234
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2235
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2236
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2237
 
 
2238
     wnga_release(a,_ga_lo, _ga_hi);
 
2239
}
 
2240
 
 
2241
void NGA_Release64(int g_a, int64_t lo[], int64_t hi[])
 
2242
{
 
2243
     Integer a=(Integer)g_a;
 
2244
     Integer ndim = wnga_ndim(a);
 
2245
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2246
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2247
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2248
 
 
2249
     wnga_release(a,_ga_lo, _ga_hi);
 
2250
}
 
2251
 
 
2252
void NGA_Release_block(int g_a, int idx)
 
2253
{
 
2254
     Integer a=(Integer)g_a;
 
2255
     Integer iblock = (Integer)idx;
 
2256
 
 
2257
     wnga_release_block(a, iblock);
 
2258
}
 
2259
 
 
2260
void NGA_Release_block_grid(int g_a, int index[])
 
2261
{
 
2262
     Integer a=(Integer)g_a;
 
2263
     Integer ndim = wnga_ndim(a);
 
2264
     Integer _ga_lo[MAXDIM];
 
2265
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
2266
 
 
2267
     wnga_release_block_grid(a, _ga_lo);
 
2268
}
 
2269
 
 
2270
void NGA_Release_block_segment(int g_a, int idx)
 
2271
{
 
2272
     Integer a=(Integer)g_a;
 
2273
     Integer iproc = (Integer)idx;
 
2274
 
 
2275
     wnga_release_block_segment(a, iproc);
 
2276
}
 
2277
 
 
2278
void NGA_Release_ghost_element(int g_a, int index[])
 
2279
{
 
2280
     Integer a=(Integer)g_a;
 
2281
     Integer ndim = wnga_ndim(a);
 
2282
     Integer _ga_lo[MAXDIM];
 
2283
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
2284
 
 
2285
     wnga_release_ghost_element(a, _ga_lo);
 
2286
}
 
2287
 
 
2288
void NGA_Release_ghost_element64(int g_a, int64_t index[])
 
2289
{
 
2290
     Integer a=(Integer)g_a;
 
2291
     Integer ndim = wnga_ndim(a);
 
2292
     Integer _ga_lo[MAXDIM];
 
2293
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
2294
 
 
2295
     wnga_release_ghost_element(a, _ga_lo);
 
2296
}
 
2297
 
 
2298
 
 
2299
void NGA_Release_ghosts(int g_a)
 
2300
{
 
2301
     Integer a=(Integer)g_a;
 
2302
 
 
2303
     wnga_release_ghosts(a);
 
2304
}
 
2305
 
 
2306
int NGA_Locate(int g_a, int subscript[])
 
2307
{
 
2308
    logical st;
 
2309
    Integer a=(Integer)g_a, owner;
 
2310
    Integer ndim = wnga_ndim(a);
 
2311
    Integer _ga_lo[MAXDIM];
 
2312
    COPYINDEX_C2F(subscript,_ga_lo,ndim);
 
2313
 
 
2314
    st = wnga_locate(a,_ga_lo,&owner);
 
2315
    if(st == TRUE) return (int)owner;
 
2316
    else return -1;
 
2317
}
 
2318
 
 
2319
int NGA_Locate64(int g_a, int64_t subscript[])
 
2320
{
 
2321
    logical st;
 
2322
    Integer a=(Integer)g_a, owner;
 
2323
    Integer ndim = wnga_ndim(a);
 
2324
    Integer _ga_lo[MAXDIM];
 
2325
    COPYINDEX_C2F(subscript,_ga_lo,ndim);
 
2326
 
 
2327
    st = wnga_locate(a,_ga_lo,&owner);
 
2328
    if(st == TRUE) return (int)owner;
 
2329
    else return -1;
 
2330
}
 
2331
 
 
2332
 
 
2333
int NGA_Locate_nnodes(int g_a, int lo[], int hi[])
 
2334
{
 
2335
     /* logical st; */
 
2336
     Integer a=(Integer)g_a, np;
 
2337
     Integer ndim = wnga_ndim(a);
 
2338
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2339
 
 
2340
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2341
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2342
     /* st = wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np); */
 
2343
     (void)wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np);
 
2344
     return (int)np;
 
2345
}
 
2346
 
 
2347
 
 
2348
int NGA_Locate_nnodes64(int g_a, int64_t lo[], int64_t hi[])
 
2349
{
 
2350
     /* logical st; */
 
2351
     Integer a=(Integer)g_a, np;
 
2352
     Integer ndim = wnga_ndim(a);
 
2353
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2354
 
 
2355
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2356
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2357
     /* st = wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np); */
 
2358
     (void)wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np);
 
2359
     return (int)np;
 
2360
}
 
2361
 
 
2362
 
 
2363
int NGA_Locate_region(int g_a,int lo[],int hi[],int map[],int procs[])
 
2364
{
 
2365
     logical st;
 
2366
     Integer a=(Integer)g_a, np_guess, np_actual;
 
2367
     Integer ndim = wnga_ndim(a);
 
2368
     Integer *tmap;
 
2369
     int i;
 
2370
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2371
     Integer *_ga_map_capi;
 
2372
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2373
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2374
     st = wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np_guess);
 
2375
     tmap = (Integer *)malloc( (int)(np_guess*2*ndim *sizeof(Integer)));
 
2376
     if(!map)GA_Error("NGA_Locate_region: unable to allocate memory",g_a);
 
2377
     _ga_map_capi = (Integer*)malloc(np_guess*sizeof(Integer));
 
2378
 
 
2379
     st = wnga_locate_region(a,_ga_lo, _ga_hi, tmap, _ga_map_capi, &np_actual);
 
2380
     assert(np_guess == np_actual);
 
2381
     if(st==FALSE){
 
2382
       free(tmap);
 
2383
       free(_ga_map_capi);
 
2384
       return 0;
 
2385
     }
 
2386
 
 
2387
     COPY(int,_ga_map_capi,procs, np_actual);
 
2388
 
 
2389
        /* might have to swap lo/hi when copying */
 
2390
 
 
2391
     for(i=0; i< np_actual*2; i++){
 
2392
        Integer *ptmap = tmap+i*ndim;
 
2393
        int *pmap = map +i*ndim;
 
2394
        COPYINDEX_F2C(ptmap, pmap, ndim);  
 
2395
     }
 
2396
     free(tmap);
 
2397
     free(_ga_map_capi);
 
2398
     return (int)np_actual;
 
2399
}
 
2400
 
 
2401
int NGA_Locate_region64(int g_a,int64_t lo[],int64_t hi[],int64_t map[],int procs[])
 
2402
{
 
2403
     logical st;
 
2404
     Integer a=(Integer)g_a, np_guess, np_actual;
 
2405
     Integer ndim = wnga_ndim(a);
 
2406
     Integer *tmap;
 
2407
     int i;
 
2408
     Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2409
     Integer *_ga_map_capi;
 
2410
     COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2411
     COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2412
     st = wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np_guess);
 
2413
     tmap = (Integer *)malloc( (int)(np_guess*2*ndim *sizeof(Integer)));
 
2414
     if(!map)GA_Error("NGA_Locate_region: unable to allocate memory",g_a);
 
2415
     _ga_map_capi = (Integer*)malloc(np_guess*sizeof(Integer));
 
2416
 
 
2417
     st = wnga_locate_region(a,_ga_lo, _ga_hi, tmap, _ga_map_capi, &np_actual);
 
2418
     assert(np_guess == np_actual);
 
2419
     if(st==FALSE){
 
2420
       free(tmap);
 
2421
       free(_ga_map_capi);
 
2422
       return 0;
 
2423
     }
 
2424
 
 
2425
     COPY(int,_ga_map_capi,procs, np_actual);
 
2426
 
 
2427
        /* might have to swap lo/hi when copying */
 
2428
 
 
2429
     for(i=0; i< np_actual*2; i++){
 
2430
        Integer *ptmap = tmap+i*ndim;
 
2431
        int64_t *pmap = map +i*ndim;
 
2432
        COPYINDEX_F2C_64(ptmap, pmap, ndim);  
 
2433
     }
 
2434
     free(tmap);
 
2435
     free(_ga_map_capi);
 
2436
     return (int)np_actual;
 
2437
}
 
2438
 
 
2439
int NGA_Locate_num_blocks(int g_a, int *lo, int *hi)
 
2440
{
 
2441
  Integer ret;
 
2442
  Integer a = (Integer)g_a;
 
2443
  Integer ndim = wnga_ndim(a);
 
2444
  Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
2445
  COPYINDEX_C2F(lo,_ga_lo,ndim);
 
2446
  COPYINDEX_C2F(hi,_ga_hi,ndim);
 
2447
  ret = wnga_locate_num_blocks(a, _ga_lo, _ga_hi);
 
2448
  return (int)ret;
 
2449
}
 
2450
 
 
2451
 
 
2452
void NGA_Inquire(int g_a, int *type, int *ndim, int dims[])
 
2453
{
 
2454
     Integer a=(Integer)g_a;
 
2455
     Integer ttype, nndim;
 
2456
     Integer _ga_dims[MAXDIM];
 
2457
     wnga_inquire(a,&ttype, &nndim, _ga_dims);
 
2458
     COPYF2C(_ga_dims, dims,nndim);  
 
2459
     *ndim = (int)nndim;
 
2460
     *type = (int)ttype;
 
2461
}
 
2462
 
 
2463
void NGA_Inquire64(int g_a, int *type, int *ndim, int64_t dims[])
 
2464
{
 
2465
     Integer a=(Integer)g_a;
 
2466
     Integer ttype, nndim;
 
2467
     Integer _ga_dims[MAXDIM];
 
2468
     wnga_inquire(a,&ttype, &nndim, _ga_dims);
 
2469
     COPYF2C_64(_ga_dims, dims,nndim);  
 
2470
     *ndim = (int)nndim;
 
2471
     *type = (int)ttype;
 
2472
}
 
2473
 
 
2474
char* GA_Inquire_name(int g_a)
 
2475
{
 
2476
     Integer a=(Integer)g_a;
 
2477
     char *ptr;
 
2478
     wnga_inquire_name(a, &ptr);
 
2479
     return(ptr);
 
2480
}
 
2481
 
 
2482
char* NGA_Inquire_name(int g_a)
 
2483
{
 
2484
     Integer a=(Integer)g_a;
 
2485
     char *ptr;
 
2486
     wnga_inquire_name(a, &ptr);
 
2487
     return(ptr);
 
2488
}
 
2489
 
 
2490
size_t GA_Memory_avail(void)
 
2491
{
 
2492
    return (size_t)wnga_memory_avail();
 
2493
}
 
2494
 
 
2495
size_t NGA_Memory_avail(void)
 
2496
{
 
2497
    return (size_t)wnga_memory_avail();
 
2498
}
 
2499
 
 
2500
int GA_Memory_limited(void)
 
2501
{
 
2502
    if(wnga_memory_limited() ==TRUE) return 1;
 
2503
    else return 0;
 
2504
}
 
2505
 
 
2506
int NGA_Memory_limited(void)
 
2507
{
 
2508
    if(wnga_memory_limited() ==TRUE) return 1;
 
2509
    else return 0;
 
2510
}
 
2511
 
 
2512
void NGA_Proc_topology(int g_a, int proc, int coord[])
 
2513
{
 
2514
     Integer a=(Integer)g_a;
 
2515
     Integer p=(Integer)proc;
 
2516
     Integer ndim = wnga_ndim(a);
 
2517
     Integer _ga_work[MAXDIM];
 
2518
     wnga_proc_topology(a, p, _ga_work);
 
2519
     COPY(int,_ga_work, coord,ndim);  
 
2520
}
 
2521
 
 
2522
void GA_Get_proc_grid(int g_a, int dims[])
 
2523
{
 
2524
     Integer a=(Integer)g_a;
 
2525
     Integer ndim = wnga_ndim(a);
 
2526
     Integer _ga_work[MAXDIM];
 
2527
     wnga_get_proc_grid(a, _ga_work);
 
2528
     COPY(int,_ga_work, dims ,ndim);  
 
2529
}
 
2530
 
 
2531
void NGA_Get_proc_grid(int g_a, int dims[])
 
2532
{
 
2533
     Integer a=(Integer)g_a;
 
2534
     Integer _ga_work[MAXDIM];
 
2535
     Integer ndim = wnga_ndim(a);
 
2536
     wnga_get_proc_grid(a, _ga_work);
 
2537
     COPY(int,_ga_work, dims ,ndim);  
 
2538
}
 
2539
 
 
2540
void GA_Check_handle(int g_a, char* string)
 
2541
{
 
2542
     Integer a=(Integer)g_a;
 
2543
     wnga_check_handle(a,string);
 
2544
}
 
2545
 
 
2546
int GA_Create_mutexes(int number)
 
2547
{
 
2548
     Integer n = (Integer)number;
 
2549
     if(wnga_create_mutexes(n) == TRUE)return 1;
 
2550
     else return 0;
 
2551
}
 
2552
 
 
2553
int NGA_Create_mutexes(int number)
 
2554
{
 
2555
     Integer n = (Integer)number;
 
2556
     if(wnga_create_mutexes(n) == TRUE)return 1;
 
2557
     else return 0;
 
2558
}
 
2559
 
 
2560
int GA_Destroy_mutexes(void) {
 
2561
  if(wnga_destroy_mutexes() == TRUE) return 1;
 
2562
  else return 0;
 
2563
}
 
2564
 
 
2565
int NGA_Destroy_mutexes(void) {
 
2566
  if(wnga_destroy_mutexes() == TRUE) return 1;
 
2567
  else return 0;
 
2568
}
 
2569
 
 
2570
void GA_Lock(int mutex)
 
2571
{
 
2572
     Integer m = (Integer)mutex;
 
2573
     wnga_lock(m);
 
2574
}
 
2575
 
 
2576
void NGA_Lock(int mutex)
 
2577
{
 
2578
     Integer m = (Integer)mutex;
 
2579
     wnga_lock(m);
 
2580
}
 
2581
 
 
2582
void GA_Unlock(int mutex)
 
2583
{
 
2584
     Integer m = (Integer)mutex;
 
2585
     wnga_unlock(m);
 
2586
}
 
2587
 
 
2588
void NGA_Unlock(int mutex)
 
2589
{
 
2590
     Integer m = (Integer)mutex;
 
2591
     wnga_unlock(m);
 
2592
}
 
2593
 
 
2594
void GA_Brdcst(void *buf, int lenbuf, int root)
 
2595
{
 
2596
  Integer type=GA_TYPE_BRD;
 
2597
  Integer len = (Integer)lenbuf;
 
2598
  Integer orig = (Integer)root;
 
2599
  wnga_msg_brdcst(type, buf, len, orig);
 
2600
}
 
2601
   
 
2602
void GA_Pgroup_brdcst(int grp_id, void *buf, int lenbuf, int root)
 
2603
{
 
2604
    Integer type=GA_TYPE_BRD;
 
2605
    Integer len = (Integer)lenbuf;
 
2606
    Integer orig = (Integer)root;
 
2607
    Integer grp = (Integer)grp_id;
 
2608
    wnga_pgroup_brdcst(grp, type, buf, len, orig);
 
2609
}
 
2610
 
 
2611
void GA_Pgroup_sync(int grp_id)
 
2612
{
 
2613
    Integer grp = (Integer)grp_id;
 
2614
    wnga_pgroup_sync(grp);
 
2615
}
 
2616
 
 
2617
void NGA_Pgroup_sync(int grp_id)
 
2618
{
 
2619
    Integer grp = (Integer)grp_id;
 
2620
    wnga_pgroup_sync(grp);
 
2621
}
 
2622
 
 
2623
void GA_Gop(int type, void *x, int n, char *op)
 
2624
{ wnga_gop(type, x, n, op); }
 
2625
 
 
2626
void GA_Igop(int x[], int n, char *op)
 
2627
{ wnga_gop(C_INT, x, n, op); }
 
2628
 
 
2629
void GA_Lgop(long x[], int n, char *op)
 
2630
{ wnga_gop(C_LONG, x, n, op); }
 
2631
 
 
2632
void GA_Llgop(long long x[], int n, char *op)
 
2633
{ wnga_gop(C_LONGLONG, x, n, op); }
 
2634
 
 
2635
void GA_Fgop(float x[], int n, char *op)
 
2636
{ wnga_gop(C_FLOAT, x, n, op); }       
 
2637
 
 
2638
void GA_Dgop(double x[], int n, char *op)
 
2639
{ wnga_gop(C_DBL, x, n, op); }
 
2640
 
 
2641
void GA_Cgop(SingleComplex x[], int n, char *op)
 
2642
{ wnga_gop(C_SCPL, x, n, op); }
 
2643
 
 
2644
void GA_Zgop(DoubleComplex x[], int n, char *op)
 
2645
{ wnga_gop(C_DCPL, x, n, op); }
 
2646
 
 
2647
void NGA_Gop(int type, void *x, int n, char *op)
 
2648
{ wnga_gop(type, x, n, op); }
 
2649
 
 
2650
void NGA_Igop(int x[], int n, char *op)
 
2651
{ wnga_gop(C_INT, x, n, op); }
 
2652
 
 
2653
void NGA_Lgop(long x[], int n, char *op)
 
2654
{ wnga_gop(C_LONG, x, n, op); }
 
2655
 
 
2656
void NGA_Llgop(long long x[], int n, char *op)
 
2657
{ wnga_gop(C_LONGLONG, x, n, op); }
 
2658
 
 
2659
void NGA_Fgop(float x[], int n, char *op)
 
2660
{ wnga_gop(C_FLOAT, x, n, op); }       
 
2661
 
 
2662
void NGA_Dgop(double x[], int n, char *op)
 
2663
{ wnga_gop(C_DBL, x, n, op); }
 
2664
 
 
2665
void NGA_Cgop(SingleComplex x[], int n, char *op)
 
2666
{ wnga_gop(C_SCPL, x, n, op); }
 
2667
 
 
2668
void NGA_Zgop(DoubleComplex x[], int n, char *op)
 
2669
{ wnga_gop(C_DCPL, x, n, op); }
 
2670
 
 
2671
void GA_Pgroup_gop(int grp_id, int type, double x[], int n, char *op)
 
2672
{ wnga_pgroup_gop(grp_id, type, x, n, op); }
 
2673
 
 
2674
void GA_Pgroup_igop(int grp_id, int x[], int n, char *op)
 
2675
{ wnga_pgroup_gop(grp_id, C_INT, x, n, op); }
 
2676
 
 
2677
void GA_Pgroup_lgop(int grp_id, long x[], int n, char *op)
 
2678
{ wnga_pgroup_gop(grp_id, C_LONG, x, n, op); }
 
2679
 
 
2680
void GA_Pgroup_llgop(int grp_id, long long x[], int n, char *op)
 
2681
{ wnga_pgroup_gop(grp_id, C_LONGLONG, x, n, op); }
 
2682
 
 
2683
void GA_Pgroup_fgop(int grp_id, float x[], int n, char *op)
 
2684
{ wnga_pgroup_gop(grp_id, C_FLOAT, x, n, op); }
 
2685
 
 
2686
void GA_Pgroup_dgop(int grp_id, double x[], int n, char *op)
 
2687
{ wnga_pgroup_gop(grp_id, C_DBL, x, n, op); }
 
2688
 
 
2689
void GA_Pgroup_cgop(int grp_id, SingleComplex x[], int n, char *op)
 
2690
{ wnga_pgroup_gop(grp_id, C_SCPL, x, n, op); }
 
2691
 
 
2692
void GA_Pgroup_zgop(int grp_id, DoubleComplex x[], int n, char *op)
 
2693
{ wnga_pgroup_gop(grp_id, C_DCPL, x, n, op); }
 
2694
 
 
2695
void NGA_Pgroup_gop(int grp_id, int type, double x[], int n, char *op)
 
2696
{ wnga_pgroup_gop(grp_id, type, x, n, op); }
 
2697
 
 
2698
void NGA_Pgroup_igop(int grp_id, int x[], int n, char *op)
 
2699
{ wnga_pgroup_gop(grp_id, C_INT, x, n, op); }
 
2700
 
 
2701
void NGA_Pgroup_lgop(int grp_id, long x[], int n, char *op)
 
2702
{ wnga_pgroup_gop(grp_id, C_LONG, x, n, op); }
 
2703
 
 
2704
void NGA_Pgroup_llgop(int grp_id, long long x[], int n, char *op)
 
2705
{ wnga_pgroup_gop(grp_id, C_LONGLONG, x, n, op); }
 
2706
 
 
2707
void NGA_Pgroup_fgop(int grp_id, float x[], int n, char *op)
 
2708
{ wnga_pgroup_gop(grp_id, C_FLOAT, x, n, op); }
 
2709
 
 
2710
void NGA_Pgroup_dgop(int grp_id, double x[], int n, char *op)
 
2711
{ wnga_pgroup_gop(grp_id, C_DBL, x, n, op); }
 
2712
 
 
2713
void NGA_Pgroup_cgop(int grp_id, SingleComplex x[], int n, char *op)
 
2714
{ wnga_pgroup_gop(grp_id, C_SCPL, x, n, op); }
 
2715
 
 
2716
void NGA_Pgroup_zgop(int grp_id, DoubleComplex x[], int n, char *op)
 
2717
{ wnga_pgroup_gop(grp_id, C_DCPL, x, n, op); }
 
2718
 
 
2719
void NGA_Alloc_gatscat_buf(int nelems)
 
2720
{
 
2721
  Integer elems = (Integer)nelems;
 
2722
  wnga_alloc_gatscat_buf(elems);
 
2723
}
 
2724
 
 
2725
void NGA_Free_gatscat_buf()
 
2726
{
 
2727
  wnga_free_gatscat_buf();
 
2728
}
 
2729
 
 
2730
void NGA_Scatter(int g_a, void *v, int* subsArray[], int n)
 
2731
{
 
2732
    int idx, i;
 
2733
    Integer a = (Integer)g_a;
 
2734
    Integer nv = (Integer)n;
 
2735
#ifndef USE_GATSCAT_NEW
 
2736
    Integer ndim = wnga_ndim(a);
 
2737
    Integer *_subs_array;
 
2738
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2739
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2740
    for(idx=0; idx<n; idx++)
 
2741
        for(i=0; i<ndim; i++)
 
2742
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2743
    wnga_scatter(a, v, _subs_array, 0, nv);
 
2744
    free(_subs_array);
 
2745
#else
 
2746
    wnga_scatter(a, v, subsArray, 1, nv);
 
2747
#endif
 
2748
}
 
2749
 
 
2750
void NGA_Scatter_flat(int g_a, void *v, int subsArray[], int n)
 
2751
{
 
2752
    int idx, i;
 
2753
    Integer a = (Integer)g_a;
 
2754
    Integer nv = (Integer)n;
 
2755
    Integer ndim = wnga_ndim(a);
 
2756
    Integer *_subs_array;
 
2757
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2758
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2759
 
 
2760
    /* adjust the indices for fortran interface */
 
2761
    for(idx=0; idx<n; idx++)
 
2762
        for(i=0; i<ndim; i++)
 
2763
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2764
    
 
2765
    wnga_scatter(a, v, _subs_array, 0, nv);
 
2766
    
 
2767
    free(_subs_array);
 
2768
}
 
2769
 
 
2770
 
 
2771
void NGA_Scatter64(int g_a, void *v, int64_t* subsArray[], int64_t n)
 
2772
{
 
2773
    int64_t idx;
 
2774
    int i;
 
2775
    Integer a = (Integer)g_a;
 
2776
    Integer nv = (Integer)n;
 
2777
#ifndef USE_GATSCAT_NEW
 
2778
    Integer ndim = wnga_ndim(a);
 
2779
    Integer *_subs_array;
 
2780
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2781
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2782
    for(idx=0; idx<n; idx++)
 
2783
        for(i=0; i<ndim; i++)
 
2784
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2785
    wnga_scatter(a, v, _subs_array, 0, nv);
 
2786
    free(_subs_array);
 
2787
#else
 
2788
    wnga_scatter(a, v, subsArray, 1, nv);
 
2789
#endif
 
2790
}
 
2791
 
 
2792
void NGA_Scatter_flat64(int g_a, void *v, int64_t subsArray[], int64_t n)
 
2793
{
 
2794
    int idx, i;
 
2795
    Integer a = (Integer)g_a;
 
2796
    Integer nv = (Integer)n;
 
2797
    Integer ndim = wnga_ndim(a);
 
2798
    Integer *_subs_array;
 
2799
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2800
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2801
 
 
2802
    /* adjust the indices for fortran interface */
 
2803
    for(idx=0; idx<n; idx++)
 
2804
        for(i=0; i<ndim; i++)
 
2805
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2806
    
 
2807
    wnga_scatter(a, v, _subs_array, 0, nv);
 
2808
    
 
2809
    free(_subs_array);
 
2810
}
 
2811
 
 
2812
 
 
2813
void NGA_Scatter_acc(int g_a, void *v, int* subsArray[], int n, void *alpha)
 
2814
{
 
2815
    int idx, i;
 
2816
    Integer a = (Integer)g_a;
 
2817
    Integer nv = (Integer)n;
 
2818
#ifndef USE_GATSCAT_NEW
 
2819
    Integer ndim = wnga_ndim(a);
 
2820
    Integer *_subs_array;
 
2821
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2822
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2823
    for(idx=0; idx<n; idx++)
 
2824
        for(i=0; i<ndim; i++)
 
2825
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2826
    wnga_scatter_acc(a, v, _subs_array, 0, nv, alpha);
 
2827
    free(_subs_array);
 
2828
#else
 
2829
    wnga_scatter_acc(a, v, subsArray, 1, nv, alpha);
 
2830
#endif
 
2831
}
 
2832
 
 
2833
void NGA_Scatter_acc_flat(int g_a, void *v, int subsArray[], int n, void *alpha)
 
2834
{
 
2835
    int idx, i;
 
2836
    Integer a = (Integer)g_a;
 
2837
    Integer nv = (Integer)n;
 
2838
    Integer ndim = wnga_ndim(a);
 
2839
    Integer *_subs_array;
 
2840
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2841
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2842
 
 
2843
    /* adjust the indices for fortran interface */
 
2844
    for(idx=0; idx<n; idx++)
 
2845
        for(i=0; i<ndim; i++)
 
2846
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2847
    
 
2848
    wnga_scatter_acc(a, v, _subs_array, 0, nv, alpha);
 
2849
    
 
2850
    free(_subs_array);
 
2851
}
 
2852
 
 
2853
void NGA_Scatter_acc64(int g_a, void *v, int64_t* subsArray[], int64_t n, void *alpha)
 
2854
{
 
2855
    int64_t idx;
 
2856
    int i;
 
2857
    Integer a = (Integer)g_a;
 
2858
    Integer nv = (Integer)n;
 
2859
#ifndef USE_GATSCAT_NEW
 
2860
    Integer ndim = wnga_ndim(a);
 
2861
    Integer *_subs_array;
 
2862
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2863
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2864
    for(idx=0; idx<n; idx++)
 
2865
        for(i=0; i<ndim; i++)
 
2866
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2867
    wnga_scatter_acc(a, v, _subs_array, 0, nv, alpha);
 
2868
    free(_subs_array);
 
2869
#else
 
2870
    wnga_scatter_acc(a, v, subsArray, 1, nv, alpha);
 
2871
#endif
 
2872
}
 
2873
 
 
2874
void NGA_Scatter_acc_flat64(int g_a, void *v, int64_t subsArray[], int64_t n, void *alpha)
 
2875
{
 
2876
    int idx, i;
 
2877
    Integer a = (Integer)g_a;
 
2878
    Integer nv = (Integer)n;
 
2879
    Integer ndim = wnga_ndim(a);
 
2880
    Integer *_subs_array;
 
2881
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2882
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2883
 
 
2884
    /* adjust the indices for fortran interface */
 
2885
    for(idx=0; idx<n; idx++)
 
2886
        for(i=0; i<ndim; i++)
 
2887
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2888
    
 
2889
    wnga_scatter_acc(a, v, _subs_array, 0, nv, alpha);
 
2890
    
 
2891
    free(_subs_array);
 
2892
}
 
2893
 
 
2894
void NGA_Gather(int g_a, void *v, int* subsArray[], int n)
 
2895
{
 
2896
    int idx, i;
 
2897
    Integer a = (Integer)g_a;
 
2898
    Integer nv = (Integer)n;
 
2899
#ifndef USE_GATSCAT_NEW
 
2900
    Integer ndim = wnga_ndim(a);
 
2901
    Integer *_subs_array;
 
2902
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2903
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2904
 
 
2905
    /* adjust the indices for fortran interface */
 
2906
    for(idx=0; idx<n; idx++)
 
2907
        for(i=0; i<ndim; i++)
 
2908
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2909
    wnga_gather(a, v, _subs_array, 0, nv);
 
2910
    free(_subs_array);
 
2911
#else
 
2912
    wnga_gather(a, v, subsArray, 1, nv);
 
2913
#endif
 
2914
}
 
2915
 
 
2916
 
 
2917
void NGA_Gather_flat(int g_a, void *v, int subsArray[], int n)
 
2918
{
 
2919
    int idx, i;
 
2920
    Integer a = (Integer)g_a;
 
2921
    Integer nv = (Integer)n;
 
2922
    Integer ndim = wnga_ndim(a);
 
2923
    Integer *_subs_array;
 
2924
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2925
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2926
 
 
2927
    /* adjust the indices for fortran interface */
 
2928
    for(idx=0; idx<n; idx++)
 
2929
        for(i=0; i<ndim; i++)
 
2930
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2931
    
 
2932
    wnga_gather(a, v, _subs_array, 0, nv);
 
2933
    
 
2934
    free(_subs_array);
 
2935
}
 
2936
 
 
2937
 
 
2938
void NGA_Gather64(int g_a, void *v, int64_t* subsArray[], int64_t n)
 
2939
{
 
2940
    int64_t idx;
 
2941
    int i;
 
2942
    Integer a = (Integer)g_a;
 
2943
    Integer nv = (Integer)n;
 
2944
#ifndef USE_GATSCAT_NEW
 
2945
    Integer ndim = wnga_ndim(a);
 
2946
    Integer *_subs_array;
 
2947
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2948
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2949
 
 
2950
    /* adjust the indices for fortran interface */
 
2951
    for(idx=0; idx<n; idx++)
 
2952
        for(i=0; i<ndim; i++)
 
2953
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
 
2954
    wnga_gather(a, v, _subs_array, 0, nv);
 
2955
    free(_subs_array);
 
2956
#else
 
2957
    wnga_gather(a, v, subsArray, 1, nv);
 
2958
#endif
 
2959
}
 
2960
 
 
2961
 
 
2962
void NGA_Gather_flat64(int g_a, void *v, int64_t subsArray[], int64_t n)
 
2963
{
 
2964
    int idx, i;
 
2965
    Integer a = (Integer)g_a;
 
2966
    Integer nv = (Integer)n;
 
2967
    Integer ndim = wnga_ndim(a);
 
2968
    Integer *_subs_array;
 
2969
    _subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
 
2970
    if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
 
2971
 
 
2972
    /* adjust the indices for fortran interface */
 
2973
    for(idx=0; idx<n; idx++)
 
2974
        for(i=0; i<ndim; i++)
 
2975
            _subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
 
2976
    
 
2977
    wnga_gather(a, v, _subs_array, 0, nv);
 
2978
    
 
2979
    free(_subs_array);
 
2980
}
 
2981
 
 
2982
 
 
2983
void GA_Dgemm_c(char ta, char tb, int m, int n, int k,
 
2984
              double alpha, int g_a, int g_b, double beta, int g_c )
 
2985
{
 
2986
  Integer G_a = g_a;
 
2987
  Integer G_b = g_b;
 
2988
  Integer G_c = g_c;
 
2989
 
 
2990
  Integer ailo = 1;
 
2991
  Integer aihi = m;
 
2992
  Integer ajlo = 1;
 
2993
  Integer ajhi = k;
 
2994
  
 
2995
  Integer bilo = 1;
 
2996
  Integer bihi = k;
 
2997
  Integer bjlo = 1;
 
2998
  Integer bjhi = n;
 
2999
  
 
3000
  Integer cilo = 1;
 
3001
  Integer cihi = m;
 
3002
  Integer cjlo = 1;
 
3003
  Integer cjhi = n;
 
3004
  
 
3005
  pnga_matmul(&ta, &tb, (DoublePrecision *)&alpha,(DoublePrecision *)&beta,
 
3006
            G_a, ailo, aihi, ajlo, ajhi,
 
3007
            G_b, bilo, bihi, bjlo, bjhi,
 
3008
            G_c, cilo, cihi, cjlo, cjhi);
 
3009
}
 
3010
 
 
3011
void GA_Zgemm_c(char ta, char tb, int m, int n, int k,
 
3012
              DoubleComplex alpha, int g_a, int g_b, 
 
3013
              DoubleComplex beta, int g_c )
 
3014
{
 
3015
  Integer G_a = g_a;
 
3016
  Integer G_b = g_b;
 
3017
  Integer G_c = g_c;
 
3018
 
 
3019
  Integer ailo = 1;
 
3020
  Integer aihi = m;
 
3021
  Integer ajlo = 1;
 
3022
  Integer ajhi = k;
 
3023
  
 
3024
  Integer bilo = 1;
 
3025
  Integer bihi = k;
 
3026
  Integer bjlo = 1;
 
3027
  Integer bjhi = n;
 
3028
  
 
3029
  Integer cilo = 1;
 
3030
  Integer cihi = m;
 
3031
  Integer cjlo = 1;
 
3032
  Integer cjhi = n;
 
3033
  
 
3034
  pnga_matmul(&ta, &tb, (DoublePrecision *)&alpha,(DoublePrecision *)&beta,
 
3035
            G_a, ailo, aihi, ajlo, ajhi,
 
3036
            G_b, bilo, bihi, bjlo, bjhi,
 
3037
            G_c, cilo, cihi, cjlo, cjhi);
 
3038
}
 
3039
 
 
3040
void GA_Cgemm_c(char ta, char tb, int m, int n, int k,
 
3041
              SingleComplex alpha, int g_a, int g_b, 
 
3042
              SingleComplex beta, int g_c )
 
3043
{
 
3044
  Integer G_a = g_a;
 
3045
  Integer G_b = g_b;
 
3046
  Integer G_c = g_c;
 
3047
 
 
3048
  Integer ailo = 1;
 
3049
  Integer aihi = m;
 
3050
  Integer ajlo = 1;
 
3051
  Integer ajhi = k;
 
3052
  
 
3053
  Integer bilo = 1;
 
3054
  Integer bihi = k;
 
3055
  Integer bjlo = 1;
 
3056
  Integer bjhi = n;
 
3057
  
 
3058
  Integer cilo = 1;
 
3059
  Integer cihi = m;
 
3060
  Integer cjlo = 1;
 
3061
  Integer cjhi = n;
 
3062
  
 
3063
  pnga_matmul(&ta, &tb, (float *)&alpha,(float *)&beta,
 
3064
            G_a, ailo, aihi, ajlo, ajhi,
 
3065
            G_b, bilo, bihi, bjlo, bjhi,
 
3066
            G_c, cilo, cihi, cjlo, cjhi);
 
3067
}
 
3068
 
 
3069
void GA_Sgemm_c(char ta, char tb, int m, int n, int k,
 
3070
              float alpha, int g_a, int g_b, 
 
3071
              float beta,  int g_c )
 
3072
{
 
3073
  Integer G_a = g_a;
 
3074
  Integer G_b = g_b;
 
3075
  Integer G_c = g_c;
 
3076
 
 
3077
  Integer ailo = 1;
 
3078
  Integer aihi = m;
 
3079
  Integer ajlo = 1;
 
3080
  Integer ajhi = k;
 
3081
  
 
3082
  Integer bilo = 1;
 
3083
  Integer bihi = k;
 
3084
  Integer bjlo = 1;
 
3085
  Integer bjhi = n;
 
3086
  
 
3087
  Integer cilo = 1;
 
3088
  Integer cihi = m;
 
3089
  Integer cjlo = 1;
 
3090
  Integer cjhi = n;
 
3091
  
 
3092
  pnga_matmul(&ta, &tb, (float*)&alpha, (float*)&beta,
 
3093
            G_a, ailo, aihi, ajlo, ajhi,
 
3094
            G_b, bilo, bihi, bjlo, bjhi,
 
3095
            G_c, cilo, cihi, cjlo, cjhi);
 
3096
}
 
3097
 
 
3098
void GA_Dgemm64_c(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3099
                double alpha, int g_a, int g_b, double beta, int g_c )
 
3100
{
 
3101
  Integer G_a = g_a;
 
3102
  Integer G_b = g_b;
 
3103
  Integer G_c = g_c;
 
3104
 
 
3105
  Integer ailo = 1;
 
3106
  Integer aihi = m;
 
3107
  Integer ajlo = 1;
 
3108
  Integer ajhi = k;
 
3109
  
 
3110
  Integer bilo = 1;
 
3111
  Integer bihi = k;
 
3112
  Integer bjlo = 1;
 
3113
  Integer bjhi = n;
 
3114
  
 
3115
  Integer cilo = 1;
 
3116
  Integer cihi = m;
 
3117
  Integer cjlo = 1;
 
3118
  Integer cjhi = n;
 
3119
  
 
3120
  pnga_matmul(&ta, &tb, (DoublePrecision *)&alpha,(DoublePrecision *)&beta,
 
3121
            G_a, ailo, aihi, ajlo, ajhi,
 
3122
            G_b, bilo, bihi, bjlo, bjhi,
 
3123
            G_c, cilo, cihi, cjlo, cjhi);
 
3124
}
 
3125
 
 
3126
void GA_Zgemm64_c(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3127
                DoubleComplex alpha, int g_a, int g_b, 
 
3128
                DoubleComplex beta, int g_c )
 
3129
{
 
3130
  Integer G_a = g_a;
 
3131
  Integer G_b = g_b;
 
3132
  Integer G_c = g_c;
 
3133
 
 
3134
  Integer ailo = 1;
 
3135
  Integer aihi = m;
 
3136
  Integer ajlo = 1;
 
3137
  Integer ajhi = k;
 
3138
  
 
3139
  Integer bilo = 1;
 
3140
  Integer bihi = k;
 
3141
  Integer bjlo = 1;
 
3142
  Integer bjhi = n;
 
3143
  
 
3144
  Integer cilo = 1;
 
3145
  Integer cihi = m;
 
3146
  Integer cjlo = 1;
 
3147
  Integer cjhi = n;
 
3148
  
 
3149
  pnga_matmul(&ta, &tb, (DoublePrecision *)&alpha,(DoublePrecision *)&beta,
 
3150
            G_a, ailo, aihi, ajlo, ajhi,
 
3151
            G_b, bilo, bihi, bjlo, bjhi,
 
3152
            G_c, cilo, cihi, cjlo, cjhi);
 
3153
}
 
3154
 
 
3155
void GA_Cgemm64_c(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3156
                SingleComplex alpha, int g_a, int g_b, 
 
3157
                SingleComplex beta, int g_c )
 
3158
{
 
3159
  Integer G_a = g_a;
 
3160
  Integer G_b = g_b;
 
3161
  Integer G_c = g_c;
 
3162
 
 
3163
  Integer ailo = 1;
 
3164
  Integer aihi = m;
 
3165
  Integer ajlo = 1;
 
3166
  Integer ajhi = k;
 
3167
  
 
3168
  Integer bilo = 1;
 
3169
  Integer bihi = k;
 
3170
  Integer bjlo = 1;
 
3171
  Integer bjhi = n;
 
3172
  
 
3173
  Integer cilo = 1;
 
3174
  Integer cihi = m;
 
3175
  Integer cjlo = 1;
 
3176
  Integer cjhi = n;
 
3177
  
 
3178
  pnga_matmul(&ta, &tb, (float *)&alpha,(float *)&beta,
 
3179
            G_a, ailo, aihi, ajlo, ajhi,
 
3180
            G_b, bilo, bihi, bjlo, bjhi,
 
3181
            G_c, cilo, cihi, cjlo, cjhi);
 
3182
}
 
3183
 
 
3184
void GA_Sgemm64_c(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3185
                float alpha, int g_a, int g_b, 
 
3186
                float beta,  int g_c )
 
3187
{
 
3188
  Integer G_a = g_a;
 
3189
  Integer G_b = g_b;
 
3190
  Integer G_c = g_c;
 
3191
 
 
3192
  Integer ailo = 1;
 
3193
  Integer aihi = m;
 
3194
  Integer ajlo = 1;
 
3195
  Integer ajhi = k;
 
3196
  
 
3197
  Integer bilo = 1;
 
3198
  Integer bihi = k;
 
3199
  Integer bjlo = 1;
 
3200
  Integer bjhi = n;
 
3201
  
 
3202
  Integer cilo = 1;
 
3203
  Integer cihi = m;
 
3204
  Integer cjlo = 1;
 
3205
  Integer cjhi = n;
 
3206
  
 
3207
  pnga_matmul(&ta, &tb, (float*)&alpha, (float*)&beta,
 
3208
            G_a, ailo, aihi, ajlo, ajhi,
 
3209
            G_b, bilo, bihi, bjlo, bjhi,
 
3210
            G_c, cilo, cihi, cjlo, cjhi);
 
3211
}
 
3212
 
 
3213
/**
 
3214
 * When calling GA _dgemm from the C, it is represented as follows (since the
 
3215
 * underlying GA dgemm implementation pnga_matmul is in Fortran style)
 
3216
 *   C(m,n) = A(m,k) * B(k,n)
 
3217
 * Since GA internally creates GAs in Fortran style, we remap the above
 
3218
 * expression to: C(n,m) = B(n,k) * A(k,m) and pass it to fortran. This
 
3219
 * produces the output C in (n,m) format, which translates to C as (m,n),and
 
3220
 * ultimately giving us the correct result.
 
3221
 */
 
3222
void GA_Dgemm(char ta, char tb, int m, int n, int k,
 
3223
              double alpha, int g_a, int g_b, double beta, int g_c )
 
3224
{
 
3225
   GA_Dgemm_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3226
}
 
3227
 
 
3228
void GA_Zgemm(char ta, char tb, int m, int n, int k,
 
3229
              DoubleComplex alpha, int g_a, int g_b, 
 
3230
              DoubleComplex beta, int g_c )
 
3231
{
 
3232
    GA_Zgemm_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3233
}
 
3234
 
 
3235
void GA_Cgemm(char ta, char tb, int m, int n, int k,
 
3236
              SingleComplex alpha, int g_a, int g_b, 
 
3237
              SingleComplex beta, int g_c )
 
3238
{
 
3239
    GA_Cgemm_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3240
}
 
3241
 
 
3242
void GA_Sgemm(char ta, char tb, int m, int n, int k,
 
3243
              float alpha, int g_a, int g_b, 
 
3244
              float beta,  int g_c )
 
3245
{
 
3246
    GA_Sgemm_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3247
}
 
3248
 
 
3249
void GA_Dgemm64(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3250
                double alpha, int g_a, int g_b, double beta, int g_c )
 
3251
{
 
3252
    GA_Dgemm64_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3253
}
 
3254
 
 
3255
void GA_Zgemm64(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3256
                DoubleComplex alpha, int g_a, int g_b, 
 
3257
                DoubleComplex beta, int g_c )
 
3258
{
 
3259
    GA_Zgemm64_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3260
}
 
3261
 
 
3262
void GA_Cgemm64(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3263
                SingleComplex alpha, int g_a, int g_b, 
 
3264
                SingleComplex beta, int g_c )
 
3265
{
 
3266
    GA_Cgemm64_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3267
}
 
3268
 
 
3269
void GA_Sgemm64(char ta, char tb, int64_t m, int64_t n, int64_t k,
 
3270
                float alpha, int g_a, int g_b, 
 
3271
                float beta,  int g_c )
 
3272
{
 
3273
    GA_Sgemm64_c(tb, ta, n, m, k, alpha, g_b, g_a, beta, g_c);
 
3274
}
 
3275
 
 
3276
/* Patch related */
 
3277
 
 
3278
void NGA_Copy_patch(char trans, int g_a, int alo[], int ahi[],
 
3279
                                int g_b, int blo[], int bhi[])
 
3280
{
 
3281
    Integer a=(Integer)g_a;
 
3282
    Integer andim = wnga_ndim(a);
 
3283
 
 
3284
    Integer b=(Integer)g_b;
 
3285
    Integer bndim = wnga_ndim(b);
 
3286
    
 
3287
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3288
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3289
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3290
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3291
    
 
3292
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3293
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3294
 
 
3295
    wnga_copy_patch(&trans, a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi);
 
3296
}
 
3297
 
 
3298
void NGA_Copy_patch64(char trans, int g_a, int64_t alo[], int64_t ahi[],
 
3299
                                  int g_b, int64_t blo[], int64_t bhi[])
 
3300
{
 
3301
    Integer a=(Integer)g_a;
 
3302
    Integer andim = wnga_ndim(a);
 
3303
 
 
3304
    Integer b=(Integer)g_b;
 
3305
    Integer bndim = wnga_ndim(b);
 
3306
    
 
3307
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3308
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3309
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3310
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3311
    
 
3312
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3313
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3314
 
 
3315
    wnga_copy_patch(&trans, a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi);
 
3316
}
 
3317
 
 
3318
void GA_Matmul_patch(char transa, char transb, void* alpha, void *beta,
 
3319
                     int g_a, int ailo, int aihi, int ajlo, int ajhi,
 
3320
                     int g_b, int bilo, int bihi, int bjlo, int bjhi,
 
3321
                     int g_c, int cilo, int cihi, int cjlo, int cjhi)
 
3322
 
 
3323
{
 
3324
    Integer Ig_a = g_a;
 
3325
    Integer Ig_b = g_b;
 
3326
    Integer Ig_c = g_c;
 
3327
#if 0
 
3328
    Integer alo[2], ahi[2]; 
 
3329
    Integer blo[2], bhi[2];
 
3330
    Integer clo[2], chi[2];
 
3331
    alo[0]=ailo+1; ahi[0]=aihi+1; alo[1]=ajlo+1; ahi[1]=ajhi+1;
 
3332
    blo[0]=bilo+1; bhi[0]=bihi+1; blo[1]=bjlo+1; bhi[1]=bjhi+1;
 
3333
    clo[0]=cilo+1; chi[0]=cihi+1; clo[1]=cjlo+1; chi[1]=cjhi+1;
 
3334
    pnga_matmul_patch(transa, transb, alpha, beta, g_a, alo, ahi,
 
3335
                         g_b, blo, bhi, g_c, clo, chi);
 
3336
#else
 
3337
    Integer Iailo=ailo+1, Iaihi=aihi+1, Iajlo=ajlo+1, Iajhi=ajhi+1;
 
3338
    Integer Ibilo=bilo+1, Ibihi=bihi+1, Ibjlo=bjlo+1, Ibjhi=bjhi+1;
 
3339
    Integer Icilo=cilo+1, Icihi=cihi+1, Icjlo=cjlo+1, Icjhi=cjhi+1;
 
3340
    if(pnga_is_mirrored(Ig_a))
 
3341
       wnga_matmul_mirrored(&transa, &transb, (void*)alpha, (void*)beta,
 
3342
                  Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
 
3343
                  Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
 
3344
                  Ig_c, Icilo, Icihi, Icjlo, Icjhi);
 
3345
    else {
 
3346
       gai_matmul_patch_flag(SET);
 
3347
       wnga_matmul(&transa, &transb, (void*)alpha, (void*)beta,
 
3348
             Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
 
3349
             Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
 
3350
             Ig_c, Icilo, Icihi, Icjlo, Icjhi);
 
3351
       gai_matmul_patch_flag(UNSET);
 
3352
    }
 
3353
#endif
 
3354
}
 
3355
 
 
3356
void GA_Matmul_patch64(char transa, char transb, void* alpha, void *beta,
 
3357
                       int g_a, int64_t ailo, int64_t aihi, int64_t ajlo, int64_t ajhi,
 
3358
                       int g_b, int64_t bilo, int64_t bihi, int64_t bjlo, int64_t bjhi,
 
3359
                       int g_c, int64_t cilo, int64_t cihi, int64_t cjlo, int64_t cjhi)
 
3360
 
 
3361
{
 
3362
    Integer Ig_a = g_a;
 
3363
    Integer Ig_b = g_b;
 
3364
    Integer Ig_c = g_c;
 
3365
#if 0
 
3366
    Integer alo[2], ahi[2]; 
 
3367
    Integer blo[2], bhi[2];
 
3368
    Integer clo[2], chi[2];
 
3369
    alo[0]=ailo+1; ahi[0]=aihi+1; alo[1]=ajlo+1; ahi[1]=ajhi+1;
 
3370
    blo[0]=bilo+1; bhi[0]=bihi+1; blo[1]=bjlo+1; bhi[1]=bjhi+1;
 
3371
    clo[0]=cilo+1; chi[0]=cihi+1; clo[1]=cjlo+1; chi[1]=cjhi+1;
 
3372
    pnga_matmul_patch(transa, transb, alpha, beta, g_a, alo, ahi,
 
3373
                         g_b, blo, bhi, g_c, clo, chi);
 
3374
#else
 
3375
    Integer Iailo=ailo+1, Iaihi=aihi+1, Iajlo=ajlo+1, Iajhi=ajhi+1;
 
3376
    Integer Ibilo=bilo+1, Ibihi=bihi+1, Ibjlo=bjlo+1, Ibjhi=bjhi+1;
 
3377
    Integer Icilo=cilo+1, Icihi=cihi+1, Icjlo=cjlo+1, Icjhi=cjhi+1;
 
3378
    if(pnga_is_mirrored(Ig_a))
 
3379
       wnga_matmul_mirrored(&transa, &transb, (void*)alpha, (void*)beta,
 
3380
                  Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
 
3381
                  Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
 
3382
                  Ig_c, Icilo, Icihi, Icjlo, Icjhi);
 
3383
    else {
 
3384
       gai_matmul_patch_flag(SET);
 
3385
       wnga_matmul(&transa, &transb, (void*)alpha, (void*)beta,
 
3386
             Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
 
3387
             Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
 
3388
             Ig_c, Icilo, Icihi, Icjlo, Icjhi);
 
3389
       gai_matmul_patch_flag(UNSET);
 
3390
    }
 
3391
#endif
 
3392
}
 
3393
 
 
3394
void NGA_Matmul_patch(char transa, char transb, void* alpha, void *beta,
 
3395
                      int g_a, int alo[], int ahi[], 
 
3396
                      int g_b, int blo[], int bhi[], 
 
3397
                      int g_c, int clo[], int chi[]) 
 
3398
 
 
3399
{
 
3400
    Integer a=(Integer)g_a;
 
3401
    Integer andim = wnga_ndim(a);
 
3402
    
 
3403
    Integer b=(Integer)g_b;
 
3404
    Integer bndim = wnga_ndim(b);
 
3405
    
 
3406
    Integer c=(Integer)g_c;
 
3407
    Integer cndim = wnga_ndim(c);
 
3408
    
 
3409
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3410
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3411
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
3412
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3413
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3414
    
 
3415
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3416
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3417
    
 
3418
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
3419
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
3420
    
 
3421
    pnga_matmul_patch(&transb, &transa, alpha, beta,
 
3422
                     b, _ga_blo, _ga_bhi,
 
3423
                     a, _ga_alo, _ga_ahi,
 
3424
                     c, _ga_clo, _ga_chi);
 
3425
}
 
3426
 
 
3427
void NGA_Matmul_patch64(char transa, char transb, void* alpha, void *beta,
 
3428
                        int g_a, int64_t alo[], int64_t ahi[], 
 
3429
                        int g_b, int64_t blo[], int64_t bhi[], 
 
3430
                        int g_c, int64_t clo[], int64_t chi[]) 
 
3431
 
 
3432
{
 
3433
    Integer a=(Integer)g_a;
 
3434
    Integer andim = wnga_ndim(a);
 
3435
    
 
3436
    Integer b=(Integer)g_b;
 
3437
    Integer bndim = wnga_ndim(b);
 
3438
    
 
3439
    Integer c=(Integer)g_c;
 
3440
    Integer cndim = wnga_ndim(c);
 
3441
    
 
3442
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3443
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3444
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
3445
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3446
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3447
    
 
3448
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3449
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3450
    
 
3451
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
3452
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
3453
    
 
3454
    pnga_matmul_patch(&transb, &transa, alpha, beta,
 
3455
                     b, _ga_blo, _ga_bhi,
 
3456
                     a, _ga_alo, _ga_ahi,
 
3457
                     c, _ga_clo, _ga_chi);
 
3458
}
 
3459
 
 
3460
int NGA_Idot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3461
                   int g_b, char t_b, int blo[], int bhi[])
 
3462
{
 
3463
    int res;
 
3464
    Integer a=(Integer)g_a;
 
3465
    Integer andim = wnga_ndim(a);
 
3466
 
 
3467
    Integer b=(Integer)g_b;
 
3468
    Integer bndim = wnga_ndim(b);
 
3469
    
 
3470
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3471
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3472
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3473
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3474
    
 
3475
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3476
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3477
 
 
3478
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3479
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3480
 
 
3481
    return res;
 
3482
}
 
3483
 
 
3484
long NGA_Ldot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3485
                    int g_b, char t_b, int blo[], int bhi[])
 
3486
{
 
3487
    long res;
 
3488
    Integer a=(Integer)g_a;
 
3489
    Integer andim = wnga_ndim(a);
 
3490
 
 
3491
    Integer b=(Integer)g_b;
 
3492
    Integer bndim = wnga_ndim(b);
 
3493
    
 
3494
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3495
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3496
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3497
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3498
    
 
3499
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3500
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3501
 
 
3502
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3503
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3504
 
 
3505
    return res;
 
3506
}
 
3507
 
 
3508
long long NGA_Lldot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3509
                    int g_b, char t_b, int blo[], int bhi[])
 
3510
{
 
3511
    long res;
 
3512
    Integer a=(Integer)g_a;
 
3513
    Integer andim = wnga_ndim(a);
 
3514
 
 
3515
    Integer b=(Integer)g_b;
 
3516
    Integer bndim = wnga_ndim(b);
 
3517
    
 
3518
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3519
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3520
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3521
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3522
    
 
3523
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3524
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3525
 
 
3526
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3527
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3528
 
 
3529
    return res;
 
3530
}
 
3531
 
 
3532
double NGA_Ddot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3533
                   int g_b, char t_b, int blo[], int bhi[])
 
3534
{
 
3535
    double res;
 
3536
    Integer a=(Integer)g_a;
 
3537
    Integer andim = wnga_ndim(a);
 
3538
 
 
3539
    Integer b=(Integer)g_b;
 
3540
    Integer bndim = wnga_ndim(b);
 
3541
 
 
3542
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3543
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3544
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3545
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3546
 
 
3547
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3548
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3549
 
 
3550
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3551
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3552
 
 
3553
    return res;
 
3554
}
 
3555
 
 
3556
DoubleComplex NGA_Zdot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3557
                             int g_b, char t_b, int blo[], int bhi[])
 
3558
{
 
3559
    DoubleComplex res;
 
3560
    
 
3561
    Integer a=(Integer)g_a;
 
3562
    Integer andim = wnga_ndim(a);
 
3563
    
 
3564
    Integer b=(Integer)g_b;
 
3565
    Integer bndim = wnga_ndim(b);
 
3566
    
 
3567
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3568
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3569
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3570
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3571
    
 
3572
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3573
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3574
    
 
3575
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3576
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3577
    
 
3578
    return res;
 
3579
}
 
3580
 
 
3581
SingleComplex NGA_Cdot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3582
                             int g_b, char t_b, int blo[], int bhi[])
 
3583
{
 
3584
    SingleComplex res;
 
3585
    
 
3586
    Integer a=(Integer)g_a;
 
3587
    Integer andim = wnga_ndim(a);
 
3588
    
 
3589
    Integer b=(Integer)g_b;
 
3590
    Integer bndim = wnga_ndim(b);
 
3591
    
 
3592
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3593
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3594
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3595
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3596
    
 
3597
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3598
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3599
    
 
3600
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3601
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3602
    
 
3603
    return res;
 
3604
}
 
3605
 
 
3606
float NGA_Fdot_patch(int g_a, char t_a, int alo[], int ahi[],
 
3607
                   int g_b, char t_b, int blo[], int bhi[])
 
3608
{
 
3609
    float res;
 
3610
    Integer a=(Integer)g_a;
 
3611
    Integer andim = wnga_ndim(a);
 
3612
 
 
3613
    Integer b=(Integer)g_b;
 
3614
    Integer bndim = wnga_ndim(b);
 
3615
 
 
3616
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3617
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3618
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3619
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3620
 
 
3621
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3622
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3623
 
 
3624
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3625
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3626
 
 
3627
    return res;
 
3628
}                                           
 
3629
 
 
3630
int NGA_Idot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3631
                     int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3632
{
 
3633
    int res;
 
3634
    Integer a=(Integer)g_a;
 
3635
    Integer andim = wnga_ndim(a);
 
3636
 
 
3637
    Integer b=(Integer)g_b;
 
3638
    Integer bndim = wnga_ndim(b);
 
3639
    
 
3640
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3641
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3642
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3643
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3644
    
 
3645
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3646
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3647
 
 
3648
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3649
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3650
 
 
3651
    return res;
 
3652
}
 
3653
 
 
3654
long NGA_Ldot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3655
                     int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3656
{
 
3657
    long res;
 
3658
    Integer a=(Integer)g_a;
 
3659
    Integer andim = wnga_ndim(a);
 
3660
 
 
3661
    Integer b=(Integer)g_b;
 
3662
    Integer bndim = wnga_ndim(b);
 
3663
    
 
3664
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3665
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3666
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3667
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3668
    
 
3669
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3670
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3671
 
 
3672
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3673
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3674
 
 
3675
    return res;
 
3676
}
 
3677
 
 
3678
long long NGA_Lldot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3679
                     int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3680
{
 
3681
    long long res;
 
3682
    Integer a=(Integer)g_a;
 
3683
    Integer andim = wnga_ndim(a);
 
3684
 
 
3685
    Integer b=(Integer)g_b;
 
3686
    Integer bndim = wnga_ndim(b);
 
3687
    
 
3688
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3689
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3690
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3691
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3692
    
 
3693
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3694
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3695
 
 
3696
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3697
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3698
 
 
3699
    return res;
 
3700
}
 
3701
 
 
3702
double NGA_Ddot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3703
                        int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3704
{
 
3705
    double res;
 
3706
    Integer a=(Integer)g_a;
 
3707
    Integer andim = wnga_ndim(a);
 
3708
 
 
3709
    Integer b=(Integer)g_b;
 
3710
    Integer bndim = wnga_ndim(b);
 
3711
 
 
3712
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3713
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3714
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3715
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3716
 
 
3717
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3718
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3719
 
 
3720
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3721
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3722
 
 
3723
    return res;
 
3724
}
 
3725
 
 
3726
DoubleComplex NGA_Zdot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3727
                               int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3728
{
 
3729
    DoubleComplex res;
 
3730
    
 
3731
    Integer a=(Integer)g_a;
 
3732
    Integer andim = wnga_ndim(a);
 
3733
    
 
3734
    Integer b=(Integer)g_b;
 
3735
    Integer bndim = wnga_ndim(b);
 
3736
    
 
3737
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3738
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3739
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3740
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3741
    
 
3742
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3743
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3744
    
 
3745
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3746
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3747
    
 
3748
    return res;
 
3749
}
 
3750
 
 
3751
SingleComplex NGA_Cdot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3752
                               int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3753
{
 
3754
    SingleComplex res;
 
3755
    
 
3756
    Integer a=(Integer)g_a;
 
3757
    Integer andim = wnga_ndim(a);
 
3758
    
 
3759
    Integer b=(Integer)g_b;
 
3760
    Integer bndim = wnga_ndim(b);
 
3761
    
 
3762
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3763
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3764
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3765
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3766
    
 
3767
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3768
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3769
    
 
3770
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3771
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3772
    
 
3773
    return res;
 
3774
}
 
3775
 
 
3776
float NGA_Fdot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
 
3777
                       int g_b, char t_b, int64_t blo[], int64_t bhi[])
 
3778
{
 
3779
    float res;
 
3780
    Integer a=(Integer)g_a;
 
3781
    Integer andim = wnga_ndim(a);
 
3782
 
 
3783
    Integer b=(Integer)g_b;
 
3784
    Integer bndim = wnga_ndim(b);
 
3785
 
 
3786
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3787
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3788
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3789
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3790
 
 
3791
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3792
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3793
 
 
3794
    wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
 
3795
                   b, &t_b, _ga_blo, _ga_bhi, &res);
 
3796
 
 
3797
    return res;
 
3798
}
 
3799
 
 
3800
 
 
3801
void NGA_Fill_patch(int g_a, int lo[], int hi[], void *val)
 
3802
{
 
3803
    Integer a=(Integer)g_a;
 
3804
    Integer ndim = wnga_ndim(a);
 
3805
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3806
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3807
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3808
 
 
3809
    wnga_fill_patch(a, _ga_lo, _ga_hi, val);
 
3810
}
 
3811
 
 
3812
void NGA_Fill_patch64(int g_a, int64_t lo[], int64_t hi[], void *val)
 
3813
{
 
3814
    Integer a=(Integer)g_a;
 
3815
    Integer ndim = wnga_ndim(a);
 
3816
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3817
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3818
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3819
 
 
3820
    wnga_fill_patch(a, _ga_lo, _ga_hi, val);
 
3821
}
 
3822
 
 
3823
void NGA_Zero_patch(int g_a, int lo[], int hi[])
 
3824
{
 
3825
    Integer a=(Integer)g_a;
 
3826
    Integer ndim = wnga_ndim(a);
 
3827
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3828
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3829
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3830
 
 
3831
    wnga_zero_patch(a, _ga_lo, _ga_hi);
 
3832
}
 
3833
 
 
3834
void NGA_Zero_patch64(int g_a, int64_t lo[], int64_t  hi[])
 
3835
{
 
3836
    Integer a=(Integer)g_a;
 
3837
    Integer ndim = wnga_ndim(a);
 
3838
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3839
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3840
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3841
 
 
3842
    wnga_zero_patch(a, _ga_lo, _ga_hi);
 
3843
}
 
3844
 
 
3845
void NGA_Scale_patch(int g_a, int lo[], int hi[], void *alpha)
 
3846
{
 
3847
    Integer a=(Integer)g_a;
 
3848
    Integer ndim = wnga_ndim(a);
 
3849
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3850
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3851
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3852
 
 
3853
    wnga_scale_patch(a, _ga_lo, _ga_hi, alpha);
 
3854
}
 
3855
 
 
3856
void NGA_Scale_patch64(int g_a, int64_t lo[], int64_t hi[], void *alpha)
 
3857
{
 
3858
    Integer a=(Integer)g_a;
 
3859
    Integer ndim = wnga_ndim(a);
 
3860
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3861
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3862
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3863
 
 
3864
    wnga_scale_patch(a, _ga_lo, _ga_hi, alpha);
 
3865
}
 
3866
 
 
3867
void NGA_Add_patch(void * alpha, int g_a, int alo[], int ahi[],
 
3868
                   void * beta,  int g_b, int blo[], int bhi[],
 
3869
                   int g_c, int clo[], int chi[])
 
3870
{
 
3871
    Integer a=(Integer)g_a;
 
3872
    Integer andim = wnga_ndim(a);
 
3873
 
 
3874
    Integer b=(Integer)g_b;
 
3875
    Integer bndim = wnga_ndim(b);
 
3876
 
 
3877
    Integer c=(Integer)g_c;
 
3878
    Integer cndim = wnga_ndim(c);
 
3879
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3880
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3881
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
3882
 
 
3883
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3884
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3885
    
 
3886
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3887
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3888
 
 
3889
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
3890
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
3891
 
 
3892
    wnga_add_patch(alpha, a, _ga_alo, _ga_ahi, beta, b, _ga_blo, _ga_bhi,
 
3893
                   c, _ga_clo, _ga_chi);
 
3894
}
 
3895
 
 
3896
void NGA_Add_patch64(void * alpha, int g_a, int64_t alo[], int64_t ahi[],
 
3897
                     void * beta,  int g_b, int64_t blo[], int64_t bhi[],
 
3898
                                   int g_c, int64_t clo[], int64_t chi[])
 
3899
{
 
3900
    Integer a=(Integer)g_a;
 
3901
    Integer andim = wnga_ndim(a);
 
3902
 
 
3903
    Integer b=(Integer)g_b;
 
3904
    Integer bndim = wnga_ndim(b);
 
3905
 
 
3906
    Integer c=(Integer)g_c;
 
3907
    Integer cndim = wnga_ndim(c);
 
3908
 
 
3909
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
3910
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
3911
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
3912
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
3913
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
3914
    
 
3915
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
3916
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
3917
 
 
3918
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
3919
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
3920
 
 
3921
    wnga_add_patch(alpha, a, _ga_alo, _ga_ahi, beta, b, _ga_blo, _ga_bhi,
 
3922
                   c, _ga_clo, _ga_chi);
 
3923
}
 
3924
 
 
3925
 
 
3926
void GA_Print_patch(int g_a,int ilo,int ihi,int jlo,int jhi,int pretty)
 
3927
{
 
3928
    Integer a = (Integer)g_a;
 
3929
    Integer lo[2];
 
3930
    Integer hi[2];
 
3931
    Integer p = (Integer) pretty;
 
3932
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3933
 
 
3934
    lo[0] = ilo; lo[1] = jlo;
 
3935
    hi[0] = ihi; lo[1] = jhi;
 
3936
    COPYINDEX_C2F(lo,_ga_lo,2);
 
3937
    COPYINDEX_C2F(hi,_ga_hi,2);
 
3938
    wnga_print_patch(a, _ga_lo, _ga_hi, p);
 
3939
}
 
3940
 
 
3941
 
 
3942
void NGA_Print_patch(int g_a, int lo[], int hi[], int pretty)
 
3943
{
 
3944
    Integer a=(Integer)g_a;
 
3945
    Integer ndim = wnga_ndim(a);
 
3946
    Integer p = (Integer)pretty;
 
3947
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3948
 
 
3949
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3950
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3951
    wnga_print_patch(a, _ga_lo, _ga_hi, p);
 
3952
}
 
3953
 
 
3954
void NGA_Print_patch64(int g_a, int64_t lo[], int64_t hi[], int pretty)
 
3955
{
 
3956
    Integer a=(Integer)g_a;
 
3957
    Integer ndim = wnga_ndim(a);
 
3958
    Integer p = (Integer)pretty;
 
3959
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
3960
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
3961
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
3962
  
 
3963
    wnga_print_patch(a, _ga_lo, _ga_hi, p);
 
3964
}
 
3965
 
 
3966
void GA_Print(int g_a)
 
3967
{
 
3968
    Integer a=(Integer)g_a;
 
3969
    wnga_print(a);
 
3970
}
 
3971
 
 
3972
void GA_Print_file(FILE *file, int g_a)
 
3973
{
 
3974
  Integer G_a = g_a;
 
3975
  wnga_print_file(file, G_a);
 
3976
}
 
3977
 
 
3978
void GA_Diag_seq(int g_a, int g_s, int g_v, void *eval)
 
3979
{
 
3980
    Integer a = (Integer)g_a;
 
3981
    Integer s = (Integer)g_s;
 
3982
    Integer v = (Integer)g_v;
 
3983
 
 
3984
    wnga_diag_seq(a, s, v, eval);
 
3985
}
 
3986
 
 
3987
void GA_Diag_std_seq(int g_a, int g_v, void *eval)
 
3988
{
 
3989
    Integer a = (Integer)g_a;
 
3990
    Integer v = (Integer)g_v;
 
3991
 
 
3992
    wnga_diag_std_seq(a, v, eval);
 
3993
}
 
3994
 
 
3995
void GA_Diag(int g_a, int g_s, int g_v, void *eval)
 
3996
{
 
3997
    Integer a = (Integer)g_a;
 
3998
    Integer s = (Integer)g_s;
 
3999
    Integer v = (Integer)g_v;
 
4000
 
 
4001
    wnga_diag(a, s, v, eval);
 
4002
}
 
4003
 
 
4004
void GA_Diag_std(int g_a, int g_v, void *eval)
 
4005
{
 
4006
    Integer a = (Integer)g_a;
 
4007
    Integer v = (Integer)g_v;
 
4008
 
 
4009
    wnga_diag_std(a, v, eval);
 
4010
}
 
4011
 
 
4012
void GA_Diag_reuse(int reuse, int g_a, int g_s, int g_v, void *eval)
 
4013
{
 
4014
    Integer r = (Integer)reuse;
 
4015
    Integer a = (Integer)g_a;
 
4016
    Integer s = (Integer)g_s;
 
4017
    Integer v = (Integer)g_v;
 
4018
 
 
4019
    wnga_diag_reuse(r, a, s, v, eval);
 
4020
}
 
4021
 
 
4022
void GA_Lu_solve(char tran, int g_a, int g_b)
 
4023
{
 
4024
    Integer a = (Integer)g_a;
 
4025
    Integer b = (Integer)g_b;
 
4026
 
 
4027
    Integer t;
 
4028
 
 
4029
    if(tran == 't' || tran == 'T') t = 1;
 
4030
    else t = 0;
 
4031
 
 
4032
    wnga_lu_solve_alt(t, a, b);
 
4033
}
 
4034
 
 
4035
int GA_Llt_solve(int g_a, int g_b)
 
4036
{
 
4037
    Integer res;
 
4038
    Integer a = (Integer)g_a;
 
4039
    Integer b = (Integer)g_b;
 
4040
 
 
4041
    res = wnga_llt_solve(a, b);
 
4042
 
 
4043
    return((int)res);
 
4044
}
 
4045
 
 
4046
int GA_Solve(int g_a, int g_b)
 
4047
{
 
4048
    Integer res;
 
4049
    Integer a = (Integer)g_a;
 
4050
    Integer b = (Integer)g_b;
 
4051
 
 
4052
    res = wnga_solve(a, b);
 
4053
 
 
4054
    return((int)res);
 
4055
}
 
4056
 
 
4057
int GA_Spd_invert(int g_a)
 
4058
{
 
4059
    Integer res;
 
4060
    Integer a = (Integer)g_a;
 
4061
 
 
4062
    res = wnga_spd_invert(a);
 
4063
 
 
4064
    return((int)res);
 
4065
}
 
4066
 
 
4067
void GA_Summarize(int verbose)
 
4068
{
 
4069
    Integer v = (Integer)verbose;
 
4070
 
 
4071
    wnga_summarize(v);
 
4072
}
 
4073
 
 
4074
void GA_Symmetrize(int g_a)
 
4075
{
 
4076
    Integer a = (Integer)g_a;
 
4077
 
 
4078
    wnga_symmetrize(a);
 
4079
}
 
4080
 
 
4081
void NGA_Symmetrize(int g_a)
 
4082
{
 
4083
    Integer a = (Integer)g_a;
 
4084
 
 
4085
    wnga_symmetrize(a);
 
4086
}
 
4087
 
 
4088
void GA_Transpose(int g_a, int g_b)
 
4089
{
 
4090
    Integer a = (Integer)g_a;
 
4091
    Integer b = (Integer)g_b;
 
4092
 
 
4093
    wnga_transpose(a, b);
 
4094
}
 
4095
 
 
4096
 
 
4097
void GA_Print_distribution(int g_a)
 
4098
{
 
4099
#ifdef USE_FAPI
 
4100
    wnga_print_distribution(1,(Integer)g_a);
 
4101
#else
 
4102
    wnga_print_distribution(0,(Integer)g_a);
 
4103
#endif
 
4104
}
 
4105
 
 
4106
 
 
4107
void NGA_Release_update(int g_a, int lo[], int hi[])
 
4108
{
 
4109
  Integer a = (Integer)g_a;
 
4110
  Integer ndim = wnga_ndim(a);
 
4111
  Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4112
  COPYINDEX_C2F(lo,_ga_lo,ndim);
 
4113
  COPYINDEX_C2F(hi,_ga_hi,ndim);
 
4114
 
 
4115
  wnga_release_update(a,_ga_lo, _ga_hi);
 
4116
}
 
4117
 
 
4118
void NGA_Release_update64(int g_a, int64_t lo[], int64_t hi[])
 
4119
{
 
4120
  Integer a = (Integer)g_a;
 
4121
  Integer ndim = wnga_ndim(a);
 
4122
  Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4123
  COPYINDEX_C2F(lo,_ga_lo,ndim);
 
4124
  COPYINDEX_C2F(hi,_ga_hi,ndim);
 
4125
 
 
4126
  wnga_release_update(a,_ga_lo, _ga_hi);
 
4127
}
 
4128
 
 
4129
void NGA_Release_update_block(int g_a, int idx)
 
4130
{
 
4131
     Integer a=(Integer)g_a;
 
4132
     Integer iblock = (Integer)idx;
 
4133
 
 
4134
     wnga_release_update_block(a, iblock);
 
4135
}
 
4136
 
 
4137
void NGA_Release_update_block_grid(int g_a, int index[])
 
4138
{
 
4139
     Integer a=(Integer)g_a;
 
4140
     Integer ndim = wnga_ndim(a);
 
4141
     Integer _ga_lo[MAXDIM];
 
4142
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
4143
     wnga_release_update_block_grid(a, _ga_lo);
 
4144
}
 
4145
 
 
4146
void NGA_Release_update_block_segment(int g_a, int idx)
 
4147
{
 
4148
     Integer a=(Integer)g_a;
 
4149
     Integer iproc = (Integer)idx;
 
4150
 
 
4151
     wnga_release_update_block_segment(a, iproc);
 
4152
}
 
4153
 
 
4154
void NGA_Release_update_ghost_element(int g_a, int index[])
 
4155
{
 
4156
     Integer a=(Integer)g_a;
 
4157
     Integer ndim = wnga_ndim(a);
 
4158
     Integer _ga_lo[MAXDIM];
 
4159
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
4160
     wnga_release_update_ghost_element(a, _ga_lo);
 
4161
}
 
4162
 
 
4163
void NGA_Release_update_ghost_element64(int g_a, int64_t index[])
 
4164
{
 
4165
     Integer a=(Integer)g_a;
 
4166
     Integer ndim = wnga_ndim(a);
 
4167
     Integer _ga_lo[MAXDIM];
 
4168
     COPYINDEX_C2F(index,_ga_lo,ndim);
 
4169
     wnga_release_update_ghost_element(a, _ga_lo);
 
4170
}
 
4171
 
 
4172
void NGA_Release_update_ghosts(int g_a)
 
4173
{
 
4174
     Integer a=(Integer)g_a;
 
4175
     wnga_release_update_ghosts(a);
 
4176
}
 
4177
 
 
4178
int GA_Ndim(int g_a)
 
4179
{
 
4180
    Integer a = (Integer)g_a;
 
4181
    return (int)wnga_ndim(a);
 
4182
}
 
4183
 
 
4184
int NGA_Ndim(int g_a)
 
4185
{
 
4186
    Integer a = (Integer)g_a;
 
4187
    return (int)wnga_ndim(a);
 
4188
}
 
4189
 
 
4190
/*Limin's functions */
 
4191
 
 
4192
 
 
4193
void GA_Step_bound_info(int g_xx, int g_vv, int g_xxll, int g_xxuu,  void *boundmin, void *wolfemin, void *boundmax)
 
4194
{
 
4195
    Integer xx = (Integer)g_xx;
 
4196
    Integer vv = (Integer)g_vv;
 
4197
    Integer xxll = (Integer)g_xxll;
 
4198
    Integer xxuu = (Integer)g_xxuu;
 
4199
    wnga_step_bound_info(xx, vv, xxll, xxuu, boundmin, wolfemin, boundmax);
 
4200
}
 
4201
 
 
4202
void GA_Step_bound_info_patch(int g_xx, int xxlo[], int xxhi[],  int g_vv, int vvlo[], int vvhi[], int g_xxll, int xxlllo[], int xxllhi[], int g_xxuu,  int xxuulo[], int xxuuhi[], void *boundmin, void *wolfemin, void *boundmax)
 
4203
{
 
4204
    Integer xx = (Integer)g_xx;
 
4205
    Integer vv = (Integer)g_vv;
 
4206
    Integer xxll = (Integer)g_xxll;
 
4207
    Integer xxuu = (Integer)g_xxuu;
 
4208
    Integer ndim = wnga_ndim(xx);
 
4209
    Integer _ga_xxlo[MAXDIM], _ga_xxhi[MAXDIM];
 
4210
    Integer _ga_vvlo[MAXDIM], _ga_vvhi[MAXDIM];
 
4211
    Integer _ga_xxlllo[MAXDIM], _ga_xxllhi[MAXDIM];
 
4212
    Integer _ga_xxuulo[MAXDIM], _ga_xxuuhi[MAXDIM];
 
4213
    COPYINDEX_C2F(xxlo,_ga_xxlo, ndim);
 
4214
    COPYINDEX_C2F(xxhi,_ga_xxhi, ndim);
 
4215
    COPYINDEX_C2F(vvlo,_ga_vvlo, ndim);
 
4216
    COPYINDEX_C2F(vvhi,_ga_vvhi, ndim);
 
4217
    COPYINDEX_C2F(xxlllo,_ga_xxlllo, ndim);
 
4218
    COPYINDEX_C2F(xxllhi,_ga_xxllhi, ndim);
 
4219
    COPYINDEX_C2F(xxuulo,_ga_xxuulo, ndim);
 
4220
    COPYINDEX_C2F(xxuuhi,_ga_xxuuhi, ndim);
 
4221
    wnga_step_bound_info_patch(xx, _ga_xxlo, _ga_xxhi, vv, _ga_vvlo, _ga_vvhi, xxll, _ga_xxlllo, _ga_xxllhi, xxuu, _ga_xxuulo, _ga_xxuuhi , 
 
4222
    boundmin,wolfemin,boundmax);
 
4223
}
 
4224
 
 
4225
void GA_Step_bound_info_patch64(int g_xx, int64_t xxlo[], int64_t xxhi[],
 
4226
                                int g_vv, int64_t vvlo[], int64_t vvhi[],
 
4227
                                int g_xxll, int64_t xxlllo[], int64_t xxllhi[],
 
4228
                                int64_t g_xxuu,  int64_t xxuulo[], int64_t xxuuhi[],
 
4229
                                void *boundmin, void *wolfemin, void *boundmax)
 
4230
{
 
4231
    Integer xx = (Integer)g_xx;
 
4232
    Integer vv = (Integer)g_vv;
 
4233
    Integer xxll = (Integer)g_xxll;
 
4234
    Integer xxuu = (Integer)g_xxuu;
 
4235
    Integer ndim = wnga_ndim(xx);
 
4236
    Integer _ga_xxlo[MAXDIM], _ga_xxhi[MAXDIM];
 
4237
    Integer _ga_vvlo[MAXDIM], _ga_vvhi[MAXDIM];
 
4238
    Integer _ga_xxlllo[MAXDIM], _ga_xxllhi[MAXDIM];
 
4239
    Integer _ga_xxuulo[MAXDIM], _ga_xxuuhi[MAXDIM];
 
4240
    COPYINDEX_C2F(xxlo,_ga_xxlo, ndim);
 
4241
    COPYINDEX_C2F(xxhi,_ga_xxhi, ndim);
 
4242
    COPYINDEX_C2F(vvlo,_ga_vvlo, ndim);
 
4243
    COPYINDEX_C2F(vvhi,_ga_vvhi, ndim);
 
4244
    COPYINDEX_C2F(xxlllo,_ga_xxlllo, ndim);
 
4245
    COPYINDEX_C2F(xxllhi,_ga_xxllhi, ndim);
 
4246
    COPYINDEX_C2F(xxuulo,_ga_xxuulo, ndim);
 
4247
    COPYINDEX_C2F(xxuuhi,_ga_xxuuhi, ndim);
 
4248
    wnga_step_bound_info_patch(xx, _ga_xxlo, _ga_xxhi, vv, _ga_vvlo, _ga_vvhi, xxll, _ga_xxlllo, _ga_xxllhi, xxuu, _ga_xxuulo, _ga_xxuuhi , 
 
4249
    boundmin,wolfemin,boundmax);
 
4250
}
 
4251
 
 
4252
void GA_Step_max(int g_a, int g_b, void *step)
 
4253
{
 
4254
    Integer a = (Integer)g_a;
 
4255
    Integer b = (Integer)g_b;
 
4256
    wnga_step_max(a, b, step);
 
4257
}
 
4258
 
 
4259
void GA_Step_max_patch(int g_a, int alo[], int ahi[], int g_b, int blo[], int bhi[], void *step)
 
4260
{
 
4261
    Integer a = (Integer)g_a;
 
4262
    Integer b = (Integer)g_b;
 
4263
    Integer ndim = wnga_ndim(a);
 
4264
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4265
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4266
    COPYINDEX_C2F(alo,_ga_alo, ndim);
 
4267
    COPYINDEX_C2F(ahi,_ga_ahi, ndim);
 
4268
    COPYINDEX_C2F(blo,_ga_blo, ndim);
 
4269
    COPYINDEX_C2F(bhi,_ga_bhi, ndim);
 
4270
    wnga_step_max_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, step);
 
4271
}
 
4272
 
 
4273
void GA_Step_max_patch64(int g_a, int64_t alo[], int64_t  ahi[],
 
4274
                         int g_b, int64_t blo[], int64_t  bhi[], void *step)
 
4275
{
 
4276
    Integer a = (Integer)g_a;
 
4277
    Integer b = (Integer)g_b;
 
4278
    Integer ndim = wnga_ndim(a);
 
4279
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4280
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4281
    COPYINDEX_C2F(alo,_ga_alo, ndim);
 
4282
    COPYINDEX_C2F(ahi,_ga_ahi, ndim);
 
4283
    COPYINDEX_C2F(blo,_ga_blo, ndim);
 
4284
    COPYINDEX_C2F(bhi,_ga_bhi, ndim);
 
4285
    wnga_step_max_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, step);
 
4286
}
 
4287
 
 
4288
void GA_Abs_value(int g_a)
 
4289
{
 
4290
    Integer a = (Integer)g_a;
 
4291
    wnga_abs_value(a);
 
4292
}
 
4293
 
 
4294
void GA_Add_constant(int g_a, void *alpha)
 
4295
{
 
4296
    Integer a = (Integer)g_a;
 
4297
    wnga_add_constant(a, alpha);
 
4298
}
 
4299
 
 
4300
 
 
4301
void GA_Recip(int g_a)
 
4302
{
 
4303
    Integer a = (Integer)g_a;
 
4304
    wnga_recip(a);
 
4305
}
 
4306
 
 
4307
void GA_Elem_multiply(int g_a, int g_b, int g_c)
 
4308
{
 
4309
    Integer a = (Integer)g_a;
 
4310
    Integer b = (Integer)g_b;
 
4311
    Integer c = (Integer)g_c;
 
4312
    wnga_elem_multiply(a, b, c);
 
4313
}
 
4314
 
 
4315
void GA_Elem_divide(int g_a, int g_b, int g_c)
 
4316
{
 
4317
    Integer a = (Integer)g_a;
 
4318
    Integer b = (Integer)g_b;
 
4319
    Integer c = (Integer)g_c;
 
4320
    wnga_elem_divide(a, b, c);
 
4321
}
 
4322
 
 
4323
void GA_Elem_maximum(int g_a, int g_b, int g_c)
 
4324
{
 
4325
    Integer a = (Integer)g_a;
 
4326
    Integer b = (Integer)g_b;
 
4327
    Integer c = (Integer)g_c;
 
4328
    wnga_elem_maximum(a, b, c);
 
4329
}
 
4330
 
 
4331
 
 
4332
void GA_Elem_minimum(int g_a, int g_b, int g_c)
 
4333
{
 
4334
    Integer a = (Integer)g_a;
 
4335
    Integer b = (Integer)g_b;
 
4336
    Integer c = (Integer)g_c;
 
4337
    wnga_elem_minimum(a, b, c);
 
4338
}
 
4339
 
 
4340
 
 
4341
void GA_Abs_value_patch(int g_a, int *lo, int *hi)
 
4342
{
 
4343
    Integer a = (Integer)g_a;
 
4344
    Integer ndim = wnga_ndim(a);
 
4345
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4346
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4347
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4348
    wnga_abs_value_patch(a,_ga_lo, _ga_hi);
 
4349
}
 
4350
 
 
4351
void GA_Abs_value_patch64(int g_a, int64_t *lo, int64_t *hi)
 
4352
{
 
4353
    Integer a = (Integer)g_a;
 
4354
    Integer ndim = wnga_ndim(a);
 
4355
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4356
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4357
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4358
    wnga_abs_value_patch(a,_ga_lo, _ga_hi);
 
4359
}
 
4360
 
 
4361
void GA_Add_constant_patch(int g_a, int *lo, int* hi, void *alpha)
 
4362
{
 
4363
    Integer a = (Integer)g_a;
 
4364
    Integer ndim = wnga_ndim(a);
 
4365
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4366
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4367
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4368
    wnga_add_constant_patch(a, _ga_lo, _ga_hi, alpha);
 
4369
}
 
4370
 
 
4371
void GA_Add_constant_patch64(int g_a, int64_t *lo, int64_t *hi, void *alpha)
 
4372
{
 
4373
    Integer a = (Integer)g_a;
 
4374
    Integer ndim = wnga_ndim(a);
 
4375
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4376
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4377
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4378
    wnga_add_constant_patch(a, _ga_lo, _ga_hi, alpha);
 
4379
}
 
4380
 
 
4381
void GA_Recip_patch(int g_a, int *lo, int *hi)
 
4382
{
 
4383
    Integer a = (Integer)g_a;
 
4384
    Integer ndim = wnga_ndim(a);
 
4385
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4386
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4387
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4388
    wnga_recip_patch(a,_ga_lo, _ga_hi);
 
4389
}
 
4390
 
 
4391
void GA_Recip_patch64(int g_a, int64_t *lo,  int64_t *hi)
 
4392
{
 
4393
    Integer a = (Integer)g_a;
 
4394
    Integer ndim = wnga_ndim(a);
 
4395
    Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
 
4396
    COPYINDEX_C2F(lo,_ga_lo, ndim);
 
4397
    COPYINDEX_C2F(hi,_ga_hi, ndim);
 
4398
    wnga_recip_patch(a,_ga_lo, _ga_hi);
 
4399
}
 
4400
 
 
4401
void GA_Elem_multiply_patch(int g_a, int alo[], int ahi[],
 
4402
                            int g_b, int blo[], int bhi[],
 
4403
                            int g_c, int clo[], int chi[])
 
4404
{
 
4405
    Integer a = (Integer)g_a;
 
4406
    Integer b = (Integer)g_b;
 
4407
    Integer c = (Integer)g_c;
 
4408
    Integer andim = wnga_ndim(a);
 
4409
    Integer bndim = wnga_ndim(b);
 
4410
    Integer cndim = wnga_ndim(c);
 
4411
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4412
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4413
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4414
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4415
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4416
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4417
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4418
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4419
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4420
    wnga_elem_multiply_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4421
}
 
4422
 
 
4423
void GA_Elem_multiply_patch64(int g_a, int64_t alo[], int64_t ahi[],
 
4424
                              int g_b, int64_t blo[], int64_t bhi[],
 
4425
                              int g_c, int64_t clo[], int64_t chi[])
 
4426
{
 
4427
    Integer a = (Integer)g_a;
 
4428
    Integer b = (Integer)g_b;
 
4429
    Integer c = (Integer)g_c;
 
4430
    Integer andim = wnga_ndim(a);
 
4431
    Integer bndim = wnga_ndim(b);
 
4432
    Integer cndim = wnga_ndim(c);
 
4433
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4434
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4435
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4436
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4437
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4438
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4439
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4440
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4441
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4442
    wnga_elem_multiply_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4443
}
 
4444
 
 
4445
void GA_Elem_divide_patch(int g_a, int alo[], int ahi[],
 
4446
                          int g_b, int blo[], int bhi[],
 
4447
                          int g_c, int clo[], int chi[])
 
4448
{
 
4449
    Integer a = (Integer)g_a;
 
4450
    Integer b = (Integer)g_b;
 
4451
    Integer c = (Integer)g_c;
 
4452
    Integer andim = wnga_ndim(a);
 
4453
    Integer bndim = wnga_ndim(b);
 
4454
    Integer cndim = wnga_ndim(c);
 
4455
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4456
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4457
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4458
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4459
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4460
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4461
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4462
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4463
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4464
    wnga_elem_divide_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4465
}
 
4466
 
 
4467
void GA_Elem_divide_patch64(int g_a, int64_t alo[], int64_t ahi[],
 
4468
                            int g_b, int64_t blo[], int64_t bhi[],
 
4469
                            int g_c, int64_t clo[], int64_t chi[])
 
4470
{
 
4471
    Integer a = (Integer)g_a;
 
4472
    Integer b = (Integer)g_b;
 
4473
    Integer c = (Integer)g_c;
 
4474
    Integer andim = wnga_ndim(a);
 
4475
    Integer bndim = wnga_ndim(b);
 
4476
    Integer cndim = wnga_ndim(c);
 
4477
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4478
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4479
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4480
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4481
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4482
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4483
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4484
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4485
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4486
    wnga_elem_divide_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4487
}
 
4488
 
 
4489
 
 
4490
void GA_Elem_maximum_patch(int g_a, int alo[], int ahi[],
 
4491
                           int g_b, int blo[], int bhi[],
 
4492
                           int g_c, int clo[], int chi[])
 
4493
{
 
4494
    Integer a = (Integer)g_a;
 
4495
    Integer b = (Integer)g_b;
 
4496
    Integer c = (Integer)g_c;
 
4497
    Integer andim = wnga_ndim(a);
 
4498
    Integer bndim = wnga_ndim(b);
 
4499
    Integer cndim = wnga_ndim(c);
 
4500
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4501
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4502
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4503
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4504
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4505
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4506
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4507
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4508
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4509
    wnga_elem_maximum_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4510
}
 
4511
 
 
4512
void GA_Elem_maximum_patch64(int g_a, int64_t alo[], int64_t ahi[],
 
4513
                             int g_b, int64_t blo[], int64_t bhi[],
 
4514
                             int g_c, int64_t clo[], int64_t chi[])
 
4515
{
 
4516
    Integer a = (Integer)g_a;
 
4517
    Integer b = (Integer)g_b;
 
4518
    Integer c = (Integer)g_c;
 
4519
    Integer andim = wnga_ndim(a);
 
4520
    Integer bndim = wnga_ndim(b);
 
4521
    Integer cndim = wnga_ndim(c);
 
4522
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4523
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4524
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4525
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4526
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4527
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4528
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4529
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4530
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4531
    wnga_elem_maximum_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4532
}
 
4533
 
 
4534
void GA_Elem_minimum_patch(int g_a, int alo[], int ahi[],
 
4535
                           int g_b, int blo[], int bhi[],
 
4536
                           int g_c, int clo[], int chi[])
 
4537
{
 
4538
    Integer a = (Integer)g_a;
 
4539
    Integer b = (Integer)g_b;
 
4540
    Integer c = (Integer)g_c;
 
4541
    Integer andim = wnga_ndim(a);
 
4542
    Integer bndim = wnga_ndim(b);
 
4543
    Integer cndim = wnga_ndim(c);
 
4544
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4545
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4546
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4547
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4548
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4549
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4550
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4551
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4552
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4553
    wnga_elem_minimum_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4554
}
 
4555
 
 
4556
void GA_Elem_minimum_patch64(int g_a, int64_t alo[], int64_t ahi[],
 
4557
                             int g_b, int64_t blo[], int64_t bhi[],
 
4558
                             int g_c, int64_t clo[], int64_t chi[])
 
4559
{
 
4560
    Integer a = (Integer)g_a;
 
4561
    Integer b = (Integer)g_b;
 
4562
    Integer c = (Integer)g_c;
 
4563
    Integer andim = wnga_ndim(a);
 
4564
    Integer bndim = wnga_ndim(b);
 
4565
    Integer cndim = wnga_ndim(c);
 
4566
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4567
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4568
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4569
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4570
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4571
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4572
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4573
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4574
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4575
    wnga_elem_minimum_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
 
4576
}
 
4577
 
 
4578
void GA_Shift_diagonal(int g_a, void *c){
 
4579
 Integer a = (Integer )g_a;
 
4580
 wnga_shift_diagonal(a, c);
 
4581
}
 
4582
 
 
4583
void GA_Set_diagonal(int g_a, int g_v){
 
4584
 Integer a = (Integer )g_a;
 
4585
 Integer v = (Integer )g_v;
 
4586
 wnga_set_diagonal(a, v);
 
4587
}
 
4588
 
 
4589
void GA_Zero_diagonal(int g_a){
 
4590
 Integer a = (Integer )g_a;
 
4591
 wnga_zero_diagonal(a);
 
4592
}
 
4593
void GA_Add_diagonal(int g_a, int g_v){
 
4594
 Integer a = (Integer )g_a;
 
4595
 Integer v = (Integer )g_v;
 
4596
 wnga_add_diagonal(a, v);
 
4597
}
 
4598
 
 
4599
void GA_Get_diag(int g_a, int g_v){
 
4600
 Integer a = (Integer )g_a;
 
4601
 Integer v = (Integer )g_v;
 
4602
 wnga_get_diag(a, v);
 
4603
}
 
4604
 
 
4605
void GA_Scale_rows(int g_a, int g_v){
 
4606
 Integer a = (Integer )g_a;
 
4607
 Integer v = (Integer )g_v;
 
4608
 wnga_scale_rows(a, v);
 
4609
}
 
4610
 
 
4611
void GA_Scale_cols(int g_a, int g_v){
 
4612
 Integer a = (Integer )g_a;
 
4613
 Integer v = (Integer )g_v;
 
4614
 wnga_scale_cols(a, v);
 
4615
}
 
4616
void GA_Norm1(int g_a, double *nm){
 
4617
 Integer a = (Integer )g_a;
 
4618
 wnga_norm1(a, nm);
 
4619
}
 
4620
 
 
4621
void GA_Norm_infinity(int g_a, double *nm){
 
4622
 Integer a = (Integer )g_a;
 
4623
 wnga_norm_infinity(a, nm);
 
4624
}
 
4625
 
 
4626
 
 
4627
void GA_Median(int g_a, int g_b, int g_c, int g_m){
 
4628
 Integer a = (Integer )g_a;
 
4629
 Integer b = (Integer )g_b;
 
4630
 Integer c= (Integer )g_c;
 
4631
 Integer m = (Integer )g_m;
 
4632
 wnga_median(a, b, c, m);
 
4633
}
 
4634
 
 
4635
void GA_Median_patch(int g_a, int *alo, int *ahi,
 
4636
                     int g_b, int *blo, int *bhi,
 
4637
                     int g_c, int *clo, int *chi,
 
4638
                     int g_m, int *mlo, int *mhi){
 
4639
 
 
4640
   Integer a = (Integer)g_a;
 
4641
    Integer b = (Integer)g_b;
 
4642
    Integer c = (Integer)g_c;
 
4643
    Integer m = (Integer )g_m;
 
4644
    Integer andim = wnga_ndim(a);
 
4645
    Integer bndim = wnga_ndim(b);
 
4646
    Integer cndim = wnga_ndim(c);
 
4647
    Integer mndim = wnga_ndim(m);
 
4648
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4649
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4650
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4651
    Integer _ga_mlo[MAXDIM], _ga_mhi[MAXDIM];
 
4652
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4653
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4654
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4655
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4656
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4657
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4658
    COPYINDEX_C2F(mlo,_ga_mlo, mndim);
 
4659
    COPYINDEX_C2F(mhi,_ga_mhi, mndim);
 
4660
    wnga_median_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi, m, _ga_mlo, _ga_mhi);
 
4661
}
 
4662
 
 
4663
void GA_Median_patch64(int g_a, int64_t *alo, int64_t *ahi,
 
4664
                       int g_b, int64_t *blo, int64_t *bhi,
 
4665
                       int g_c, int64_t *clo, int64_t *chi,
 
4666
                       int g_m, int64_t *mlo, int64_t *mhi){
 
4667
 
 
4668
   Integer a = (Integer)g_a;
 
4669
    Integer b = (Integer)g_b;
 
4670
    Integer c = (Integer)g_c;
 
4671
    Integer m = (Integer )g_m;
 
4672
    Integer andim = wnga_ndim(a);
 
4673
    Integer bndim = wnga_ndim(b);
 
4674
    Integer cndim = wnga_ndim(c);
 
4675
    Integer mndim = wnga_ndim(m);
 
4676
    Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
 
4677
    Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
 
4678
    Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
 
4679
    Integer _ga_mlo[MAXDIM], _ga_mhi[MAXDIM];
 
4680
    COPYINDEX_C2F(alo,_ga_alo, andim);
 
4681
    COPYINDEX_C2F(ahi,_ga_ahi, andim);
 
4682
    COPYINDEX_C2F(blo,_ga_blo, bndim);
 
4683
    COPYINDEX_C2F(bhi,_ga_bhi, bndim);
 
4684
    COPYINDEX_C2F(clo,_ga_clo, cndim);
 
4685
    COPYINDEX_C2F(chi,_ga_chi, cndim);
 
4686
    COPYINDEX_C2F(mlo,_ga_mlo, mndim);
 
4687
    COPYINDEX_C2F(mhi,_ga_mhi, mndim);
 
4688
    wnga_median_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi, m, _ga_mlo, _ga_mhi);
 
4689
}
 
4690
 
 
4691
/* return number of nodes being used in a cluster */
 
4692
int GA_Cluster_nnodes()
 
4693
{
 
4694
    return wnga_cluster_nnodes();
 
4695
} 
 
4696
 
 
4697
/* returns ClusterNode id of the calling process */
 
4698
int GA_Cluster_nodeid() 
 
4699
{
 
4700
    return wnga_cluster_nodeid();
 
4701
}
 
4702
 
 
4703
/* returns ClusterNode id of the specified process */
 
4704
int GA_Cluster_proc_nodeid(int proc)
 
4705
{
 
4706
    Integer aproc = proc;
 
4707
    return wnga_cluster_proc_nodeid(aproc);
 
4708
}
 
4709
 
 
4710
/* return number of processes being used on the specified node */
 
4711
int GA_Cluster_nprocs(int x) 
 
4712
{
 
4713
    Integer ax = x;
 
4714
    return wnga_cluster_nprocs(ax);
 
4715
}
 
4716
 
 
4717
/* global id of the calling process */
 
4718
int GA_Cluster_procid(int node, int loc_proc)
 
4719
{
 
4720
    Integer anode = node;
 
4721
    Integer aloc_proc = loc_proc;
 
4722
    return wnga_cluster_procid(anode, aloc_proc);
 
4723
}
 
4724
 
 
4725
double GA_Wtime()
 
4726
{
 
4727
    return (double)wnga_wtime();
 
4728
}
 
4729
 
 
4730
void GA_Set_debug(int flag)
 
4731
{
 
4732
    Integer aa;
 
4733
    aa = (Integer)flag;
 
4734
    wnga_set_debug(aa);
 
4735
}
 
4736
 
 
4737
void NGA_Set_debug(int flag)
 
4738
{
 
4739
    Integer aa;
 
4740
    aa = (Integer)flag;
 
4741
    wnga_set_debug(aa);
 
4742
}
 
4743
 
 
4744
int GA_Get_debug()
 
4745
{
 
4746
    return (int)wnga_get_debug();
 
4747
}
 
4748
 
 
4749
int NGA_Get_debug()
 
4750
{
 
4751
    return (int)wnga_get_debug();
 
4752
}
 
4753
 
 
4754
#ifdef ENABLE_CHECKPOINT
 
4755
void GA_Checkpoint(int* gas, int num)
 
4756
{
 
4757
    wnga_checkpoint_arrays(gas,num);
 
4758
}
 
4759
#endif
 
4760
 
 
4761
int GA_Pgroup_absolute_id(int grp_id, int pid) {
 
4762
  Integer agrp_id = (Integer)grp_id;
 
4763
  Integer apid = (Integer) pid;
 
4764
  return (int)wnga_pgroup_absolute_id(agrp_id, apid);
 
4765
}
 
4766
 
 
4767
int NGA_Pgroup_absolute_id(int grp_id, int pid) {
 
4768
  Integer agrp_id = (Integer)grp_id;
 
4769
  Integer apid = (Integer) pid;
 
4770
  return (int)wnga_pgroup_absolute_id(agrp_id, apid);
 
4771
}
 
4772
 
 
4773
void GA_Error(char *str, int code)
 
4774
{
 
4775
    Integer icode = code;
 
4776
    wnga_error(str, icode);
 
4777
}
 
4778
 
 
4779
void NGA_Error(char *str, int code)
 
4780
{
 
4781
    Integer icode = code;
 
4782
    wnga_error(str, icode);
 
4783
}
 
4784
 
 
4785
size_t GA_Inquire_memory()
 
4786
{
 
4787
    return (size_t)wnga_inquire_memory();
 
4788
}
 
4789
 
 
4790
size_t NGA_Inquire_memory()
 
4791
{
 
4792
    return (size_t)wnga_inquire_memory();
 
4793
}
 
4794
 
 
4795
void GA_Sync()
 
4796
{
 
4797
    wnga_sync();
 
4798
}
 
4799
 
 
4800
void NGA_Sync()
 
4801
{
 
4802
    wnga_sync();
 
4803
}
 
4804
 
 
4805
int GA_Uses_ma()
 
4806
{
 
4807
    return wnga_uses_ma();
 
4808
}
 
4809
 
 
4810
int NGA_Uses_ma()
 
4811
{
 
4812
    return wnga_uses_ma();
 
4813
}
 
4814
 
 
4815
void GA_Print_stats()
 
4816
{
 
4817
    wnga_print_stats();
 
4818
}
 
4819
 
 
4820
void GA_Init_fence()
 
4821
{
 
4822
    wnga_init_fence();
 
4823
}
 
4824
 
 
4825
void NGA_Init_fence()
 
4826
{
 
4827
    wnga_init_fence();
 
4828
}
 
4829
 
 
4830
void GA_Fence()
 
4831
{
 
4832
    wnga_fence();
 
4833
}
 
4834
 
 
4835
void NGA_Fence()
 
4836
{
 
4837
    wnga_fence();
 
4838
}
 
4839
 
 
4840
int GA_Nodeid()
 
4841
{
 
4842
    return wnga_nodeid();
 
4843
}
 
4844
 
 
4845
int NGA_Nodeid()
 
4846
{
 
4847
    return wnga_nodeid();
 
4848
}
 
4849
 
 
4850
int GA_Nnodes()
 
4851
{
 
4852
    return wnga_nnodes();
 
4853
}
 
4854
 
 
4855
int NGA_Nnodes()
 
4856
{
 
4857
    return wnga_nnodes();
 
4858
}
 
4859
 
 
4860
static Integer* copy_map(int block[], int block_ndim, int map[])
 
4861
{
 
4862
    int d;
 
4863
    int i,sum=0,capi_offset=0,map_offset=0;
 
4864
    Integer *_ga_map_capi;
 
4865
 
 
4866
    for (d=0; d<block_ndim; d++) {
 
4867
        sum += block[d];
 
4868
    }
 
4869
 
 
4870
    _ga_map_capi = (Integer*)malloc(sum * sizeof(Integer));
 
4871
 
 
4872
    capi_offset = sum;
 
4873
    for (d=0; d<block_ndim; d++) {
 
4874
        capi_offset -= block[d];
 
4875
        for (i=0; i<block[d]; i++) {
 
4876
            _ga_map_capi[capi_offset+i] = map[map_offset+i] + 1;
 
4877
        }
 
4878
        map_offset += block[d];
 
4879
    }
 
4880
 
 
4881
    return _ga_map_capi;
 
4882
}
 
4883
 
 
4884
static Integer* copy_map64(int64_t block[], int block_ndim, int64_t map[])
 
4885
{
 
4886
    int d;
 
4887
    int64_t i,sum=0,capi_offset=0,map_offset=0;
 
4888
    Integer *_ga_map_capi;
 
4889
 
 
4890
    for (d=0; d<block_ndim; d++) {
 
4891
        sum += block[d];
 
4892
    }
 
4893
 
 
4894
    _ga_map_capi = (Integer*)malloc(sum * sizeof(Integer));
 
4895
 
 
4896
    capi_offset = sum;
 
4897
    for (d=0; d<block_ndim; d++) {
 
4898
        capi_offset -= block[d];
 
4899
        for (i=0; i<block[d]; i++) {
 
4900
            _ga_map_capi[capi_offset+i] = map[map_offset+i] + 1;
 
4901
        }
 
4902
        map_offset += block[d];
 
4903
    }
 
4904
 
 
4905
    return _ga_map_capi;
 
4906
}
 
4907
 
 
4908
int NGA_Register_type(size_t bytes) {
 
4909
  return wnga_register_type(bytes);
 
4910
}
 
4911
 
 
4912
int NGA_Deregister_type(int type) {
 
4913
  return wnga_deregister_type(type);
 
4914
}
 
4915
 
 
4916
 
 
4917
void NGA_Get_field(int g_a, int *lo, int *hi, int foff, int fsize,
 
4918
                   void *buf, int *ld) {
 
4919
  Integer a = (Integer)g_a;
 
4920
  Integer andim = wnga_ndim(a);
 
4921
  Integer _alo[MAXDIM], _ahi[MAXDIM];
 
4922
  Integer _ld[MAXDIM];
 
4923
  COPYINDEX_C2F(lo,_alo, andim);
 
4924
  COPYINDEX_C2F(hi,_ahi, andim);
 
4925
  COPYINDEX_C2F(ld, _ld, andim-1);
 
4926
 
 
4927
  wnga_get_field(a, _alo, _ahi, foff, fsize, buf, _ld);
 
4928
}
 
4929
 
 
4930
void NGA_Nbget_field(int g_a, int *lo, int *hi, int foff, int fsize,
 
4931
                     void *buf, int *ld, ga_nbhdl_t *nbhandle) {
 
4932
  Integer a = (Integer)g_a;
 
4933
  Integer andim = wnga_ndim(a);
 
4934
  Integer _alo[MAXDIM], _ahi[MAXDIM];
 
4935
  Integer _ld[MAXDIM];
 
4936
  COPYINDEX_C2F(lo,_alo, andim);
 
4937
  COPYINDEX_C2F(hi,_ahi, andim);
 
4938
  COPYINDEX_C2F(ld, _ld, andim-1);
 
4939
 
 
4940
  wnga_nbget_field(a, _alo, _ahi, foff, fsize, buf, _ld, (Integer*)nbhandle);
 
4941
}
 
4942
 
 
4943
void NGA_Nbput_field(int g_a, int *lo, int *hi, int foff, int fsize,
 
4944
                     void *buf, int *ld, ga_nbhdl_t *nbhandle) {
 
4945
  Integer a = (Integer)g_a;
 
4946
  Integer andim = wnga_ndim(a);
 
4947
  Integer _alo[MAXDIM], _ahi[MAXDIM];
 
4948
  Integer _ld[MAXDIM];
 
4949
  COPYINDEX_C2F(lo,_alo, andim);
 
4950
  COPYINDEX_C2F(hi,_ahi, andim);
 
4951
  COPYINDEX_C2F(ld, _ld, andim-1);
 
4952
 
 
4953
  wnga_nbput_field(a, _alo, _ahi, foff, fsize, buf, _ld, (Integer*)nbhandle);
 
4954
}
 
4955
 
 
4956
void NGA_Put_field(int g_a, int *lo, int *hi, int foff, int fsize,
 
4957
                   void *buf, int *ld) {
 
4958
  Integer a = (Integer)g_a;
 
4959
  Integer andim = wnga_ndim(a);
 
4960
  Integer _alo[MAXDIM], _ahi[MAXDIM];
 
4961
  Integer _ld[MAXDIM];
 
4962
  COPYINDEX_C2F(lo,_alo, andim);
 
4963
  COPYINDEX_C2F(hi,_ahi, andim);
 
4964
  COPYINDEX_C2F(ld, _ld, andim-1);
 
4965
 
 
4966
  wnga_put_field(a, _alo, _ahi, foff, fsize, buf, _ld);
 
4967
}
 
4968
 
 
4969
 
 
4970