Date: 2015-09-03T15:04:20+00:00

Actual source code: veccomp.c
slepc-3.6.1 2015-09-03
Report Typos and Errors

      1: /*
      2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      4:    Copyright (c) 2002-2015, Universitat Politecnica de Valencia, Spain

      6:    This file is part of SLEPc.

      8:    SLEPc is free software: you can redistribute it and/or modify it under  the
      9:    terms of version 3 of the GNU Lesser General Public License as published by
     10:    the Free Software Foundation.

     12:    SLEPc  is  distributed in the hope that it will be useful, but WITHOUT  ANY
     13:    WARRANTY;  without even the implied warranty of MERCHANTABILITY or  FITNESS
     14:    FOR  A  PARTICULAR PURPOSE. See the GNU Lesser General Public  License  for
     15:    more details.

     17:    You  should have received a copy of the GNU Lesser General  Public  License
     18:    along with SLEPc. If not, see <http://www.gnu.org/licenses/>.
     19:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     20: */

     22: #include <slepc/private/vecimplslepc.h>     /*I "slepcvec.h" I*/

     24: /* Private MPI datatypes and operators */
     25: static MPI_Datatype MPIU_NORM2=0, MPIU_NORM1_AND_2=0;
     26: static MPI_Op MPIU_NORM2_SUM=0;
     27: static PetscBool VecCompInitialized = PETSC_FALSE;

     29: /* Private inline functions */
     30: PETSC_STATIC_INLINE void SumNorm2(PetscReal *,PetscReal *,PetscReal *,PetscReal *);
     31: PETSC_STATIC_INLINE PetscReal GetNorm2(PetscReal,PetscReal);
     32: PETSC_STATIC_INLINE void AddNorm2(PetscReal *,PetscReal *,PetscReal);

     34: #include "veccomp0.h"

     37: #include "veccomp0.h"

     39: PETSC_STATIC_INLINE void SumNorm2(PetscReal *ssq0,PetscReal *scale0,PetscReal *ssq1,PetscReal *scale1)
     40: {
     41:   PetscReal q;
     42:   if (*scale0 > *scale1) {
     43:     q = *scale1/(*scale0);
     44:     *ssq1 = *ssq0 + q*q*(*ssq1);
     45:     *scale1 = *scale0;
     46:   } else {
     47:     q = *scale0/(*scale1);
     48:     *ssq1 += q*q*(*ssq0);
     49:   }
     50: }

     52: PETSC_STATIC_INLINE PetscReal GetNorm2(PetscReal ssq,PetscReal scale)
     53: {
     54:   return scale*PetscSqrtReal(ssq);
     55: }

     57: PETSC_STATIC_INLINE void AddNorm2(PetscReal *ssq,PetscReal *scale,PetscReal x)
     58: {
     59:   PetscReal absx,q;
     60:   if (x != 0.0) {
     61:     absx = PetscAbs(x);
     62:     if (*scale < absx) {
     63:       q = *scale/absx;
     64:       *ssq = 1.0 + *ssq*q*q;
     65:       *scale = absx;
     66:     } else {
     67:       q = absx/(*scale);
     68:       *ssq += q*q;
     69:     }
     70:   }
     71: }

     75: static void SlepcSumNorm2_Local(void *in,void *out,PetscMPIInt *cnt,MPI_Datatype *datatype)
     76: {
     77:   PetscInt i,count = *cnt;

     80:   if (*datatype == MPIU_NORM2) {
     81:     PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;
     82:     for (i=0; i<count; i++) {
     83:       SumNorm2(&xin[i*2],&xin[i*2+1],&xout[i*2],&xout[i*2+1]);
     84:     }
     85:   } else if (*datatype == MPIU_NORM1_AND_2) {
     86:     PetscReal *xin = (PetscReal*)in,*xout = (PetscReal*)out;
     87:     for (i=0; i<count; i++) {
     88:       xout[i*3]+= xin[i*3];
     89:       SumNorm2(&xin[i*3+1],&xin[i*3+2],&xout[i*3+1],&xout[i*3+2]);
     90:     }
     91:   } else {
     92:     (*PetscErrorPrintf)("Can only handle MPIU_NORM* data types");
     93:     MPI_Abort(MPI_COMM_WORLD,1);
     94:   }
     95:   PetscFunctionReturnVoid();
     96: }

    100: static PetscErrorCode VecNormCompEnd(void)
    101: {

    105:   MPI_Type_free(&MPIU_NORM2);
    106:   MPI_Type_free(&MPIU_NORM1_AND_2);
    107:   MPI_Op_free(&MPIU_NORM2_SUM);
    108:   VecCompInitialized = PETSC_FALSE;
    109:   return(0);
    110: }

    114: static PetscErrorCode VecNormCompInit()
    115: {

    119:   MPI_Type_contiguous(sizeof(PetscReal)*2,MPI_BYTE,&MPIU_NORM2);
    120:   MPI_Type_commit(&MPIU_NORM2);
    121:   MPI_Type_contiguous(sizeof(PetscReal)*3,MPI_BYTE,&MPIU_NORM1_AND_2);
    122:   MPI_Type_commit(&MPIU_NORM1_AND_2);
    123:   MPI_Op_create(SlepcSumNorm2_Local,1,&MPIU_NORM2_SUM);
    124:   PetscRegisterFinalize(VecNormCompEnd);
    125:   return(0);
    126: }

    130: PetscErrorCode VecDestroy_Comp(Vec v)
    131: {
    132:   Vec_Comp       *vs = (Vec_Comp*)v->data;
    133:   PetscInt       i;

    137: #if defined(PETSC_USE_LOG)
    138:   PetscLogObjectState((PetscObject)v,"Length=%D",v->map->n);
    139: #endif
    140:   for (i=0;i<vs->nx;i++) {
    141:     VecDestroy(&vs->x[i]);
    142:   }
    143:   if (--vs->n->friends <= 0) {
    144:     PetscFree(vs->n);
    145:   }
    146:   PetscFree(vs->x);
    147:   PetscFree(vs);
    148:   return(0);
    149: }

    151: static struct _VecOps DvOps = {VecDuplicate_Comp, /* 1 */
    152:             VecDuplicateVecs_Comp,
    153:             VecDestroyVecs_Comp,
    154:             VecDot_Comp_MPI,
    155:             VecMDot_Comp_MPI,
    156:             VecNorm_Comp_MPI,
    157:             VecTDot_Comp_MPI,
    158:             VecMTDot_Comp_MPI,
    159:             VecScale_Comp,
    160:             VecCopy_Comp, /* 10 */
    161:             VecSet_Comp,
    162:             VecSwap_Comp,
    163:             VecAXPY_Comp,
    164:             VecAXPBY_Comp,
    165:             VecMAXPY_Comp,
    166:             VecAYPX_Comp,
    167:             VecWAXPY_Comp,
    168:             VecAXPBYPCZ_Comp,
    169:             VecPointwiseMult_Comp,
    170:             VecPointwiseDivide_Comp,
    171:             0, /* 20 */
    172:             0,0,
    173:             0 /*VecGetArray_Seq*/,
    174:             VecGetSize_Comp,
    175:             VecGetLocalSize_Comp,
    176:             0/*VecRestoreArray_Seq*/,
    177:             VecMax_Comp,
    178:             VecMin_Comp,
    179:             VecSetRandom_Comp,
    180:             0, /* 30 */
    181:             0,
    182:             VecDestroy_Comp,
    183:             VecView_Comp,
    184:             0/*VecPlaceArray_Seq*/,
    185:             0/*VecReplaceArray_Seq*/,
    186:             VecDot_Comp_Seq,
    187:             0,
    188:             VecNorm_Comp_Seq,
    189:             VecMDot_Comp_Seq,
    190:             0, /* 40 */
    191:             0,
    192:             VecReciprocal_Comp,
    193:             VecConjugate_Comp,
    194:             0,0,
    195:             0/*VecResetArray_Seq*/,
    196:             0,
    197:             VecMaxPointwiseDivide_Comp,
    198:             VecPointwiseMax_Comp,
    199:             VecPointwiseMaxAbs_Comp,
    200:             VecPointwiseMin_Comp,
    201:             0,
    202:             VecSqrtAbs_Comp,
    203:             VecAbs_Comp,
    204:             VecExp_Comp,
    205:             VecLog_Comp,
    206:             0/*VecShift_Comp*/,
    207:             0,
    208:             0,
    209:             0,
    210:             VecDotNorm2_Comp_MPI
    211:           };

    215: PetscErrorCode VecDuplicateVecs_Comp(Vec w,PetscInt m,Vec *V[])
    216: {
    218:   PetscInt       i;

    223:   if (m<=0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"m must be > 0: m = %D",m);
    224:   PetscMalloc1(m,V);
    225:   for (i=0;i<m;i++) { VecDuplicate(w,*V+i); }
    226:   return(0);
    227: }

    231: PetscErrorCode VecDestroyVecs_Comp(PetscInt m,Vec v[])
    232: {
    234:   PetscInt       i;

    238:   if (m<=0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"m must be > 0: m = %D",m);
    239:   for (i=0;i<m;i++) if (v[i]) { VecDestroy(&v[i]); }
    240:   PetscFree(v);
    241:   return(0);
    242: }

    246: static PetscErrorCode VecCreate_Comp_Private(Vec v,Vec *x,PetscInt nx,PetscBool x_to_me,Vec_Comp_N *n)
    247: {
    248:   Vec_Comp       *s;
    250:   PetscInt       N=0,lN=0,i,k;

    253:   if (!VecCompInitialized) {
    254:     VecCompInitialized = PETSC_TRUE;
    255:     VecRegister(VECCOMP,VecCreate_Comp);
    256:     VecNormCompInit();
    257:   }

    259:   /* Allocate a new Vec_Comp */
    260:   if (v->data) { PetscFree(v->data); }
    261:   PetscNewLog(v,&s);
    262:   PetscMemcpy(v->ops,&DvOps,sizeof(DvOps));
    263:   v->data        = (void*)s;
    264:   v->petscnative = PETSC_FALSE;

    266:   /* Allocate the array of Vec, if it is needed to be done */
    267:   if (x_to_me != PETSC_TRUE) {
    268:     PetscMalloc(sizeof(Vec)*nx,&s->x);
    269:     PetscMemcpy(s->x,x,sizeof(Vec)*nx);
    270:   } else s->x = x;

    272:   s->nx = nx;

    274:   /* Allocate the shared structure, if it is not given */
    275:   if (!n) {
    276:     for (i=0;i<nx;i++) {
    277:       VecGetSize(x[i],&k);
    278:       N+= k;
    279:       VecGetLocalSize(x[i],&k);
    280:       lN+= k;
    281:     }
    282:     PetscNewLog(v,&n);
    283:     s->n = n;
    284:     n->n = nx;
    285:     n->N = N;
    286:     n->lN = lN;
    287:     n->friends = 1;
    288:   } else { /* If not, check in the vector in the shared structure */
    289:     N = n->N;
    290:     lN = n->lN;
    291:     s->n = n;
    292:     s->n->friends++;
    293:   }

    295:   /* Set the virtual sizes as the real sizes of the vector */
    296:   VecSetSizes(v,s->n->lN,s->n->N);

    298:   PetscObjectChangeTypeName((PetscObject)v,VECCOMP);
    299:   return(0);
    300: }

    304: PETSC_EXTERN PetscErrorCode VecCreate_Comp(Vec V)
    305: {

    309:   VecCreate_Comp_Private(V,NULL,0,PETSC_FALSE,NULL);
    310:   return(0);
    311: }

    315: /*@C
    316:    VecCreateComp - Creates a new vector containing several subvectors,
    317:    each stored separately.

    319:    Collective on Vec

    321:    Input Parameters:
    322: +  comm - communicator for the new Vec
    323: .  Nx   - array of (initial) global sizes of child vectors
    324: .  n    - number of child vectors
    325: .  t    - type of the child vectors
    326: -  Vparent - (optional) template vector

    328:    Output Parameter:
    329: .  V - new vector

    331:    Notes:
    332:    This is similar to PETSc's VecNest but customized for SLEPc's needs. In particular,
    333:    the number of child vectors can be modified dynamically, with VecCompSetSubVecs().

    335:    Level: developer

    337: .seealso: VecCreateCompWithVecs(), VecCompSetSubVecs()
    338: @*/
    339: PetscErrorCode VecCreateComp(MPI_Comm comm,PetscInt *Nx,PetscInt n,VecType t,Vec Vparent,Vec *V)
    340: {
    342:   Vec            *x;
    343:   PetscInt       i;

    346:   VecCreate(comm,V);
    347:   PetscMalloc1(n,&x);
    348:   PetscLogObjectMemory((PetscObject)*V,n*sizeof(Vec));
    349:   for (i=0;i<n;i++) {
    350:     VecCreate(comm,&x[i]);
    351:     VecSetSizes(x[i],PETSC_DECIDE,Nx[i]);
    352:     VecSetType(x[i],t);
    353:   }
    354:   VecCreate_Comp_Private(*V,x,n,PETSC_TRUE,Vparent?((Vec_Comp*)Vparent->data)->n:NULL);
    355:   return(0);
    356: }

    360: /*@C
    361:    VecCreateCompWithVecs - Creates a new vector containing several subvectors,
    362:    each stored separately, from an array of Vecs.

    364:    Collective on Vec

    366:    Input Parameters:
    367: +  x - array of Vecs
    368: .  n - number of child vectors
    369: -  Vparent - (optional) template vector

    371:    Output Parameter:
    372: .  V - new vector

    374:    Level: developer

    376: .seealso: VecCreateComp()
    377: @*/
    378: PetscErrorCode VecCreateCompWithVecs(Vec *x,PetscInt n,Vec Vparent,Vec *V)
    379: {
    381:   PetscInt       i;

    384:   VecCreate(PetscObjectComm((PetscObject)x[0]),V);
    385:   for (i=0;i<n;i++) {
    386:     PetscObjectReference((PetscObject)x[i]);
    387:   }
    388:   VecCreate_Comp_Private(*V,x,n,PETSC_FALSE,Vparent?((Vec_Comp*)Vparent->data)->n:NULL);
    389:   return(0);
    390: }

    394: PetscErrorCode VecDuplicate_Comp(Vec win,Vec *V)
    395: {
    397:   Vec            *x;
    398:   PetscInt       i;
    399:   Vec_Comp       *s = (Vec_Comp*)win->data;

    402:   SlepcValidVecComp(win);
    403:   VecCreate(PetscObjectComm((PetscObject)win),V);
    404:   PetscMalloc1(s->nx,&x);
    405:   PetscLogObjectMemory((PetscObject)*V,s->nx*sizeof(Vec));
    406:   for (i=0;i<s->nx;i++) {
    407:     if (s->x[i]) {
    408:       VecDuplicate(s->x[i],&x[i]);
    409:     } else x[i] = NULL;
    410:   }
    411:   VecCreate_Comp_Private(*V,x,s->nx,PETSC_TRUE,s->n);
    412:   return(0);
    413: }

    417: /*@C
    418:    VecCompGetSubVecs - Returns the entire array of vectors defining a
    419:    compound vector.

    421:    Collective on Vec

    423:    Input Parameter:
    424: .  win - compound vector

    426:    Output Parameters:
    427: +  n - number of child vectors
    428: -  x - array of child vectors

    430:    Level: developer

    432: .seealso: VecCreateComp()
    433: @*/
    434: PetscErrorCode VecCompGetSubVecs(Vec win,PetscInt *n,const Vec **x)
    435: {
    436:   Vec_Comp *s = (Vec_Comp*)win->data;

    439:   SlepcValidVecComp(win);
    440:   if (x) *x = s->x;
    441:   if (n) *n = s->nx;
    442:   return(0);
    443: }

    447: /*@C
    448:    VecCompSetSubVecs - Resets the number of subvectors defining a compound vector,
    449:    of replaces the subvectors.

    451:    Collective on Vec

    453:    Input Parameters:
    454: +  win - compound vector
    455: .  n - number of child vectors
    456: -  x - array of child vectors

    458:    Level: developer

    460: .seealso: VecCreateComp()
    461: @*/
    462: PetscErrorCode VecCompSetSubVecs(Vec win,PetscInt n,Vec *x)
    463: {
    464:   Vec_Comp       *s = (Vec_Comp*)win->data;

    468:   if (x) {
    469:     if (n > s->nx) {
    470:       PetscFree(s->x);
    471:       PetscMalloc(sizeof(Vec)*n,&s->x);
    472:     }
    473:     PetscMemcpy(s->x,x,sizeof(Vec)*n);
    474:     s->nx = n;
    475:   }
    476:   s->n->n = n;
    477:   return(0);
    478: }

    482: PetscErrorCode VecAXPY_Comp(Vec v,PetscScalar alpha,Vec w)
    483: {
    485:   Vec_Comp       *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data;
    486:   PetscInt       i;

    489:   SlepcValidVecComp(v);
    490:   SlepcValidVecComp(w);
    491:   for (i=0;i<vs->n->n;i++) {
    492:     VecAXPY(vs->x[i],alpha,ws->x[i]);
    493:   }
    494:   return(0);
    495: }

    499: PetscErrorCode VecAYPX_Comp(Vec v,PetscScalar alpha,Vec w)
    500: {
    502:   Vec_Comp       *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data;
    503:   PetscInt       i;

    506:   SlepcValidVecComp(v);
    507:   SlepcValidVecComp(w);
    508:   for (i=0;i<vs->n->n;i++) {
    509:     VecAYPX(vs->x[i],alpha,ws->x[i]);
    510:   }
    511:   return(0);
    512: }

    516: PetscErrorCode VecAXPBY_Comp(Vec v,PetscScalar alpha,PetscScalar beta,Vec w)
    517: {
    519:   Vec_Comp       *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data;
    520:   PetscInt       i;

    523:   SlepcValidVecComp(v);
    524:   SlepcValidVecComp(w);
    525:   for (i=0;i<vs->n->n;i++) {
    526:     VecAXPBY(vs->x[i],alpha,beta,ws->x[i]);
    527:   }
    528:   return(0);
    529: }

    533: PetscErrorCode VecMAXPY_Comp(Vec v,PetscInt n,const PetscScalar *alpha,Vec *w)
    534: {
    536:   Vec_Comp       *vs = (Vec_Comp*)v->data;
    537:   Vec            *wx;
    538:   PetscInt       i,j;

    541:   SlepcValidVecComp(v);
    542:   for (i=0;i<n;i++) SlepcValidVecComp(w[i]);

    544:   PetscMalloc(sizeof(Vec)*n,&wx);

    546:   for (j=0;j<vs->n->n;j++) {
    547:     for (i=0;i<n;i++) wx[i] = ((Vec_Comp*)w[i]->data)->x[j];
    548:     VecMAXPY(vs->x[j],n,alpha,wx);
    549:   }

    551:   PetscFree(wx);
    552:   return(0);
    553: }

    557: PetscErrorCode VecWAXPY_Comp(Vec v,PetscScalar alpha,Vec w,Vec z)
    558: {
    560:   Vec_Comp       *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data,*zs = (Vec_Comp*)z->data;
    561:   PetscInt       i;

    564:   SlepcValidVecComp(v);
    565:   SlepcValidVecComp(w);
    566:   SlepcValidVecComp(z);
    567:   for (i=0;i<vs->n->n;i++) {
    568:     VecWAXPY(vs->x[i],alpha,ws->x[i],zs->x[i]);
    569:   }
    570:   return(0);
    571: }

    575: PetscErrorCode VecAXPBYPCZ_Comp(Vec v,PetscScalar alpha,PetscScalar beta,PetscScalar gamma,Vec w,Vec z)
    576: {
    577:   PetscErrorCode  ierr;
    578:   Vec_Comp        *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data,*zs = (Vec_Comp*)z->data;
    579:   PetscInt        i;

    582:   SlepcValidVecComp(v);
    583:   SlepcValidVecComp(w);
    584:   SlepcValidVecComp(z);
    585:   for (i=0;i<vs->n->n;i++) {
    586:     VecAXPBYPCZ(vs->x[i],alpha,beta,gamma,ws->x[i],zs->x[i]);
    587:   }
    588:   return(0);
    589: }

    593: PetscErrorCode VecGetSize_Comp(Vec v,PetscInt *size)
    594: {
    595:   Vec_Comp *vs = (Vec_Comp*)v->data;

    598:   SlepcValidVecComp(v);
    600:   *size = vs->n->N;
    601:   return(0);
    602: }

    606: PetscErrorCode VecGetLocalSize_Comp(Vec v,PetscInt *size)
    607: {
    608:   Vec_Comp *vs = (Vec_Comp*)v->data;

    611:   SlepcValidVecComp(v);
    613:   *size = vs->n->lN;
    614:   return(0);
    615: }

    619: PetscErrorCode VecMax_Comp(Vec v,PetscInt *idx,PetscReal *z)
    620: {
    622:   Vec_Comp       *vs = (Vec_Comp*)v->data;
    623:   PetscInt       idxp,s=0,s0;
    624:   PetscReal      zp,z0;
    625:   PetscInt       i;

    628:   SlepcValidVecComp(v);
    629:   if (!idx && !z) return(0);

    631:   if (vs->n->n > 0) {
    632:     VecMax(vs->x[0],idx?&idxp:NULL,&zp);
    633:   }
    634:   for (i=1;i<vs->n->n;i++) {
    635:     VecGetSize(vs->x[i-1],&s0);
    636:     s+= s0;
    637:     VecMax(vs->x[i],idx?&idxp:NULL,&z0);
    638:     if (zp < z0) {
    639:       if (idx) *idx = s+idxp;
    640:       zp = z0;
    641:     }
    642:   }
    643:   if (z) *z = zp;
    644:   return(0);
    645: }

    649: PetscErrorCode VecMin_Comp(Vec v,PetscInt *idx,PetscReal *z)
    650: {
    652:   Vec_Comp       *vs = (Vec_Comp*)v->data;
    653:   PetscInt       idxp,s=0,s0;
    654:   PetscReal      zp,z0;
    655:   PetscInt       i;

    658:   SlepcValidVecComp(v);
    659:   if (!idx && !z) return(0);

    661:   if (vs->n->n > 0) {
    662:     VecMin(vs->x[0],idx?&idxp:NULL,&zp);
    663:   }
    664:   for (i=1;i<vs->n->n;i++) {
    665:     VecGetSize(vs->x[i-1],&s0);
    666:     s+= s0;
    667:     VecMin(vs->x[i],idx?&idxp:NULL,&z0);
    668:     if (zp > z0) {
    669:       if (idx) *idx = s+idxp;
    670:       zp = z0;
    671:     }
    672:   }
    673:   if (z) *z = zp;
    674:   return(0);
    675: }

    679: PetscErrorCode VecMaxPointwiseDivide_Comp(Vec v,Vec w,PetscReal *m)
    680: {
    682:   Vec_Comp       *vs = (Vec_Comp*)v->data,*ws = (Vec_Comp*)w->data;
    683:   PetscReal      work;
    684:   PetscInt       i;

    687:   SlepcValidVecComp(v);
    688:   SlepcValidVecComp(w);
    689:   if (!m || vs->n->n == 0) return(0);
    690:   VecMaxPointwiseDivide(vs->x[0],ws->x[0],m);
    691:   for (i=1;i<vs->n->n;i++) {
    692:     VecMaxPointwiseDivide(vs->x[i],ws->x[i],&work);
    693:     *m = PetscMax(*m,work);
    694:   }
    695:   return(0);
    696: }

    704: PetscErrorCode __COMPOSE3__(Vec,NAME,_Comp)(Vec v) \
    705: { \
    706:   PetscErrorCode  ierr; \
    707:   Vec_Comp        *vs = (Vec_Comp*)v->data; \
    708:   PetscInt        i; \
    709: \
    711:   SlepcValidVecComp(v); \
    712:   for (i=0;i<vs->n->n;i++) { \
    713:     __COMPOSE2__(Vec,NAME)(vs->x[i]); \
    714:   } \
    715:   return(0);\
    716: }

    720: __FUNC_TEMPLATE1__(Conjugate)

    724: __FUNC_TEMPLATE1__(Reciprocal)

    728: __FUNC_TEMPLATE1__(SqrtAbs)

    732: __FUNC_TEMPLATE1__(Abs)

    736: __FUNC_TEMPLATE1__(Exp)

    740: __FUNC_TEMPLATE1__(Log)

    744: PetscErrorCode __COMPOSE3__(Vec,NAME,_Comp)(Vec v,T0 __a) \
    745: { \
    746:   PetscErrorCode  ierr; \
    747:   Vec_Comp        *vs = (Vec_Comp*)v->data; \
    748:   PetscInt        i; \
    749: \
    751:   SlepcValidVecComp(v); \
    752:   for (i=0;i<vs->n->n;i++) { \
    753:     __COMPOSE2__(Vec,NAME)(vs->x[i],__a); \
    754:   } \
    755:   return(0);\
    756: }

    760: __FUNC_TEMPLATE2__(Set,PetscScalar)

    764: __FUNC_TEMPLATE2__(View,PetscViewer)

    768: __FUNC_TEMPLATE2__(Scale,PetscScalar)

    772: __FUNC_TEMPLATE2__(SetRandom,PetscRandom)

    776: __FUNC_TEMPLATE2__(Shift,PetscScalar)

    780: PetscErrorCode __COMPOSE3__(Vec,NAME,_Comp)(Vec v,Vec w) \
    781: { \
    782:   PetscErrorCode  ierr; \
    783:   Vec_Comp        *vs = (Vec_Comp*)v->data,\
    784:                   *ws = (Vec_Comp*)w->data; \
    785:   PetscInt        i; \
    786: \
    788:   SlepcValidVecComp(v); \
    789:   SlepcValidVecComp(w); \
    790:   for (i=0;i<vs->n->n;i++) { \
    791:     __COMPOSE2__(Vec,NAME)(vs->x[i],ws->x[i]); \
    792:   } \
    793:   return(0);\
    794: }

    798: __FUNC_TEMPLATE3__(Copy)

    802: __FUNC_TEMPLATE3__(Swap)

    806: PetscErrorCode __COMPOSE3__(Vec,NAME,_Comp)(Vec v,Vec w,Vec z) \
    807: { \
    808:   PetscErrorCode  ierr; \
    809:   Vec_Comp        *vs = (Vec_Comp*)v->data, \
    810:                   *ws = (Vec_Comp*)w->data, \
    811:                   *zs = (Vec_Comp*)z->data; \
    812:   PetscInt        i; \
    813: \
    815:   SlepcValidVecComp(v); \
    816:   SlepcValidVecComp(w); \
    817:   SlepcValidVecComp(z); \
    818:   for (i=0;i<vs->n->n;i++) { \
    819:     __COMPOSE2__(Vec,NAME)(vs->x[i],ws->x[i],zs->x[i]); \
    820:   } \
    821:   return(0);\
    822: }

    826: __FUNC_TEMPLATE4__(PointwiseMax)

    830: __FUNC_TEMPLATE4__(PointwiseMaxAbs)

    834: __FUNC_TEMPLATE4__(PointwiseMin)

    838: __FUNC_TEMPLATE4__(PointwiseMult)

    842: __FUNC_TEMPLATE4__(PointwiseDivide)