IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 21, 2005, 4:32:00 PM (21 years ago)
Author:
drobbin
Message:

Added psVectorGet/Set and tests. Added prototype for psImageCountPixelMask.

Location:
trunk/psLib/src/mathtypes
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/mathtypes/psVector.c

    r5087 r5089  
    99*  @author Robert DeSonia, MHPCC
    1010*
    11 *  @version $Revision: 1.53 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2005-09-21 21:37:21 $
     11*  @version $Revision: 1.54 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2005-09-22 02:32:00 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    746746
    747747#define FUNC_MACRO_VECTOR_CREATE(TYPE) \
    748 static psVector *vectorCreate##TYPE(double lower, double upper, double delta) \
     748static psVector *vectorCreate##TYPE(psVector *input, double lower, double upper, double delta) \
    749749{ \
    750750    \
    751751    int nBin = (upper - lower) / delta; \
    752     psVector *vec = psVectorAlloc(nBin, PS_TYPE_##TYPE); \
     752    psVector *vec = psVectorRecycle(input, nBin, PS_TYPE_##TYPE); \
    753753    for (int i = 0; i < nBin; i++) \
    754754    { \
    … …  
    769769FUNC_MACRO_VECTOR_CREATE(F64)
    770770
    771 psVector *psVectorCreate (double lower,
     771psVector *psVectorCreate (psVector *input,
     772                          double lower,
    772773                          double upper,
    773774                          double delta,
    … …  
    777778    switch (type) {
    778779    case PS_TYPE_S8:
    779         out = vectorCreateS8( lower,  upper, delta);
     780        out = vectorCreateS8(input, lower,  upper, delta);
    780781        break;
    781782    case PS_TYPE_S16:
    782         out = vectorCreateS16(lower, upper, delta);
     783        out = vectorCreateS16(input, lower, upper, delta);
    783784        break;
    784785    case PS_TYPE_S32:
    785         out = vectorCreateS32(lower, upper, delta);
     786        out = vectorCreateS32(input, lower, upper, delta);
    786787        break;
    787788    case PS_TYPE_S64:
    788         out = vectorCreateS64(lower, upper, delta);
     789        out = vectorCreateS64(input, lower, upper, delta);
    789790        break;
    790791    case PS_TYPE_U8:
    791         out = vectorCreateU8(lower, upper, delta);
     792        out = vectorCreateU8(input, lower, upper, delta);
    792793        break;
    793794    case PS_TYPE_U16:
    794         out = vectorCreateU16(lower, upper, delta);
     795        out = vectorCreateU16(input, lower, upper, delta);
    795796        break;
    796797    case PS_TYPE_U32:
    797         out = vectorCreateU32(lower, upper, delta);
     798        out = vectorCreateU32(input, lower, upper, delta);
    798799        break;
    799800    case PS_TYPE_U64:
    800         out = vectorCreateU64(lower, upper, delta);
     801        out = vectorCreateU64(input, lower, upper, delta);
    801802        break;
    802803    case PS_TYPE_F32:
    803         out = vectorCreateF32(lower, upper, delta);
     804        out = vectorCreateF32(input, lower, upper, delta);
    804805        break;
    805806    case PS_TYPE_F64:
    806         out = vectorCreateF64(lower, upper, delta);
     807        out = vectorCreateF64(input, lower, upper, delta);
    807808        break;
    808809    default:
    809810        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psType for Vector Create\n");
    810811    }
    811     /*
    812       for (int i = 0; i < nBin; i++) {
    813         out->data.F64[i] = lower + i * delta;
    814       }
    815     */
    816812    return (out);
    817813}
    818814
     815bool psVectorSet(const psVector *input,
     816                 long position,
     817                 complex value)
     818{
     819    if (input == NULL)
     820        return false;
     821    if (position >= input->n)
     822        return false;
     823    if(position < 0)
     824        position += input->n;
     825
     826    switch (input->type.type) {
     827    case PS_TYPE_U8:
     828        *(psU8*)&input->data.U8[position] = value;
     829        break;
     830    case PS_TYPE_U16:
     831        *(psU16*)&input->data.U16[position] = value;
     832        break;
     833    case PS_TYPE_U32:
     834        *(psU32*)&input->data.U32[position] = value;
     835        break;
     836    case PS_TYPE_U64:
     837        *(psU64*)&input->data.U64[position] = value;
     838        break;
     839    case PS_TYPE_S8:
     840        *(psS8*)&input->data.S8[position] = value;
     841        break;
     842    case PS_TYPE_S16:
     843        *(psS16*)&input->data.S16[position] = value;
     844        break;
     845    case PS_TYPE_S32:
     846        *(psS32*)&input->data.S32[position] = value;
     847        break;
     848    case PS_TYPE_S64:
     849        *(psS64*)&input->data.S64[position] = value;
     850        break;
     851    case PS_TYPE_F32:
     852        *(psF32*)&input->data.F32[position] = value;
     853        break;
     854    case PS_TYPE_F64:
     855        *(psF64*)&input->data.F64[position] = value;
     856        break;
     857    case PS_TYPE_C32:
     858        *(psC32*)&input->data.C32[position] = value;
     859        break;
     860    case PS_TYPE_C64:
     861        *(psC64*)&input->data.C64[position] = value;
     862        break;
     863    default:
     864        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Invalid psVector Data Type\n");
     865    }
     866
     867    return true;
     868}
     869
     870complex psVectorGet(const psVector *input,
     871                    long position)
     872{
     873    if (input == NULL)
     874        return NAN;
     875    if (position >= input->n) {
     876        return NAN;
     877    }
     878    if(position < 0)
     879        position += input->n;
     880
     881    switch (input->type.type) {
     882    case PS_TYPE_U8:
     883        return input->data.U8[position];
     884        break;
     885    case PS_TYPE_U16:
     886        return input->data.U16[position];
     887        break;
     888    case PS_TYPE_U32:
     889        return input->data.U32[position];
     890        break;
     891    case PS_TYPE_U64:
     892        return input->data.U64[position];
     893        break;
     894    case PS_TYPE_S8:
     895        return input->data.S8[position];
     896        break;
     897    case PS_TYPE_S16:
     898        return input->data.S16[position];
     899        break;
     900    case PS_TYPE_S32:
     901        return input->data.S32[position];
     902        break;
     903    case PS_TYPE_S64:
     904        return input->data.S64[position];
     905        break;
     906    case PS_TYPE_F32:
     907        return input->data.F32[position];
     908        break;
     909    case PS_TYPE_F64:
     910        return input->data.F64[position];
     911        break;
     912    case PS_TYPE_C32:
     913        return input->data.C32[position];
     914        break;
     915    case PS_TYPE_C64:
     916        return input->data.C64[position];
     917        break;
     918    default:
     919        return NAN;
     920    }
     921
     922}
     923

  • trunk/psLib/src/mathtypes/psVector.h

    r5087 r5089  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-09-21 21:37:21 $
     13 *  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-09-22 02:32:00 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    217217 */
    218218psVector *psVectorCreate (
     219    psVector *input,                   ///< Input vector
    219220    double lower,                      ///< lower bound
    220221    double upper,                      ///< upper bound
    … …  
    223224);
    224225
     226/** Sets the value of the input vector at the specified position to value.
     227 *
     228 *  A negative position means index from the end.
     229 *
     230 *  @return bool:       True if successful, otherwise false.
     231 */
     232bool psVectorSet(
     233    const psVector *input,             ///< Input vector to set
     234    long position,                     ///< vector position
     235    complex value                      ///< value to set
     236);
     237
     238/** Returns the value of the input vector at the specified position.
     239 *
     240 *  A negative position means index from the end.
     241 *
     242 *  @return complex:        Value of the input vector at the specified position.
     243 */
     244complex psVectorGet(
     245    const psVector *input,             ///< Input vector from which to get value
     246    long position                      ///< vector position
     247);
     248
    225249/// @}
    226250
Note: See TracChangeset for help on using the changeset viewer.