IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Apr 16, 2020, 2:04:27 PM (6 years ago)
Author:
tdeboer
Message:

quick undo

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libfits/table/F_set_column.c

    r41340 r41341  
    253253/***********************/
    254254// convert the input data array (of the specified intype) to the desired table data type. swap unless nativeOrder is requested
    255 int gfits_set_bintable_column_reformat (Header *header, FTable *table, char *label, char *intype, void *data, off_t Nrow, char nativeOrder) {
     255int gfits_set_bintable_column_reformat (Header *header, FTable *table, char *label, char *intype, void *data, off_t Nrow, int element, char nativeOrder) {
    256256
    257257  off_t Nx, Ny;
    … …  
    288288
    289289  if (!gfits_bintable_format (format, outtype, &Nval, &NbytesOut)) return (FALSE);
     290  if (element >= Nval) {
     291    fprintf (stderr, "programming error: element >= Nval for field %s, format %s\n", label, format);
     292    return FALSE;
     293  }
    290294 
    291295  /* check existing table dimensions */
    … …  
    307311  }
    308312
     313  // NOTE: we are inserting a single column into the output
     314  // table.  If the output field is multi-value, the resulting
     315  // array is inserted into the appropriate bytes in that output field
     316
    309317  /* make duplicate of data with correct type
    310318     byte swap and Bzero/Bscale */
    311   ALLOCATE (array, char, NbytesOut*Nval*Nrow);
     319  ALLOCATE (array, char, NbytesOut*Nrow);
    312320  Pin = data;
    313   Pout = array;
     321  Pout = array; //
    314322
    315323  // # define ASSIGN_DATA(ITYPE,INAME,ISIZE,OTYPE,ONAME)
    … …  
    321329  if (!strcmp (outtype, OUTNAME) && !strcmp (intype, INNAME)) {         \
    322330    int NbytesIn = NBYTES_IN;                                           \
    323     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { \
     331    for (i = 0; i < Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { \
    324332      if (directCopy) {                                                 \
    325333        *(OUTTYPE *)Pout = *(INTYPE *)Pin;                              \
    … …  
    385393  SET_VALUES("double",   double, "double", double, SWAP_DBLE, 8);
    386394
    387 # if (0)
    388   /** input == char **/
    389   if (!strcmp (outtype, "char") && !strcmp (intype, "char")) {
    390     int NbytesIn = 1;
    391     for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) {
    392       if (directCopy) { *(char *)Pout = *(char *)Pin; } else {
    393         *(char *)Pout = (*(char *)Pin - Bzero) / Bscale;
    394       }
    395     }
    396   }
    397   if (!strcmp (outtype, "byte") && !strcmp (intype, "char")) {
    398     int NbytesIn = 1;
    399     for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) {
    400       if (directCopy) { *(char *)Pout = *(char *)Pin; } else {
    401         *(char *)Pout = (*(char *)Pin - Bzero) / Bscale;
    402       }
    403     }
    404   }
    405   if (!strcmp (outtype, "short") && !strcmp (intype, "char")) {
    406     int NbytesIn = 1;
    407     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    408       if (directCopy) { *(short *)Pout = *(char *)Pin; } else {
    409         *(short *)Pout = (*(char *)Pin - Bzero) / Bscale;
    410       }
    411 # ifdef BYTE_SWAP
    412       if (!nativeOrder) { SWAP_BYTE; }
    413 # endif
    414     } 
    415   }
    416   if (!strcmp (outtype, "int") && !strcmp (intype, "char")) {
    417     int NbytesIn = 1;
    418     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    419       *(int *)Pout = (*(char *)Pin - Bzero) / Bscale;
    420 # ifdef BYTE_SWAP
    421       if (!nativeOrder) { SWAP_WORD; }
    422 # endif
    423     }
    424   }
    425   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "char")) {
    426     int NbytesIn = 1;
    427     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    428       *(int64_t *)Pout = (*(char *)Pin - Bzero) / Bscale;
    429 # ifdef BYTE_SWAP
    430       if (!nativeOrder) { SWAP_DBLE; }
    431 # endif
    432     }
    433   }
    434   if (!strcmp (outtype, "float") && !strcmp (intype, "char")) {
    435     int NbytesIn = 1;
    436     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    437       *(float *)Pout = (*(char *)Pin - Bzero) / Bscale;
    438 # ifdef BYTE_SWAP
    439       if (!nativeOrder) { SWAP_WORD; }
    440 # endif
    441     }
    442   }
    443   if (!strcmp (outtype, "double") && !strcmp (intype, "char")) {
    444     int NbytesIn = 1;
    445     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    446       *(double *)Pout = (*(char *)Pin - Bzero) / Bscale;
    447 # ifdef BYTE_SWAP
    448       if (!nativeOrder) { SWAP_DBLE; }
    449 # endif
    450     }
    451   }
    452 
    453   /** input == byte **/
    454   if (!strcmp (outtype, "char") && !strcmp (intype, "byte")) {
    455     int NbytesIn = 1;
    456     for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) {
    457       *(char *)Pout = (*(char *)Pin - Bzero) / Bscale;
    458     }
    459   }
    460   if (!strcmp (outtype, "byte") && !strcmp (intype, "byte")) {
    461     int NbytesIn = 1;
    462     for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) {
    463       *(char *)Pout = (*(char *)Pin - Bzero) / Bscale;
    464     }
    465   }
    466   if (!strcmp (outtype, "short") && !strcmp (intype, "byte")) {
    467     int NbytesIn = 1;
    468     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    469       *(short *)Pout = (*(char *)Pin - Bzero) / Bscale;
    470 # ifdef BYTE_SWAP
    471       if (!nativeOrder) { SWAP_BYTE; }
    472 # endif
    473     } 
    474   }
    475   if (!strcmp (outtype, "int") && !strcmp (intype, "byte")) {
    476     int NbytesIn = 1;
    477     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    478       *(int *)Pout = (*(char *)Pin - Bzero) / Bscale;
    479 # ifdef BYTE_SWAP
    480       if (!nativeOrder) { SWAP_WORD; }
    481 # endif
    482     }
    483   }
    484   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "byte")) {
    485     int NbytesIn = 1;
    486     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    487       *(int64_t *)Pout = (*(char *)Pin - Bzero) / Bscale;
    488 # ifdef BYTE_SWAP
    489       if (!nativeOrder) { SWAP_DBLE; }
    490 # endif
    491     }
    492   }
    493   if (!strcmp (outtype, "float") && !strcmp (intype, "byte")) {
    494     int NbytesIn = 1;
    495     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    496       *(float *)Pout = (*(char *)Pin - Bzero) / Bscale;
    497 # ifdef BYTE_SWAP
    498       if (!nativeOrder) { SWAP_WORD; }
    499 # endif
    500     }
    501   }
    502   if (!strcmp (outtype, "double") && !strcmp (intype, "byte")) {
    503     int NbytesIn = 1;
    504     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    505       *(double *)Pout = (*(char *)Pin - Bzero) / Bscale;
    506 # ifdef BYTE_SWAP
    507       if (!nativeOrder) { SWAP_DBLE; }
    508 # endif
    509     }
    510   }
    511 
    512   /** input == short **/
    513   if (!strcmp (outtype, "char") && !strcmp (intype, "short")) {
    514     int NbytesIn = 2;
    515     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    516       *(char *)Pout = (*(short *)Pin - Bzero) / Bscale;
    517     }
    518   }
    519   if (!strcmp (outtype, "byte") && !strcmp (intype, "short")) {
    520     int NbytesIn = 2;
    521     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    522       *(char *)Pout = (*(short *)Pin - Bzero) / Bscale;
    523     }
    524   }
    525   if (!strcmp (outtype, "short") && !strcmp (intype, "short")) {
    526     int NbytesIn = 2;
    527     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    528       *(short *)Pout = (*(short *)Pin - Bzero) / Bscale;
    529 # ifdef BYTE_SWAP
    530       if (!nativeOrder) { SWAP_BYTE; }
    531 # endif
    532     } 
    533   }
    534   if (!strcmp (outtype, "int") && !strcmp (intype, "short")) {
    535     int NbytesIn = 2;
    536     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    537       *(int *)Pout = (*(short *)Pin - Bzero) / Bscale;
    538 # ifdef BYTE_SWAP
    539       if (!nativeOrder) { SWAP_WORD; }
    540 # endif
    541     }
    542   }
    543   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "short")) {
    544     int NbytesIn = 2;
    545     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    546       *(int64_t *)Pout = (*(short *)Pin - Bzero) / Bscale;
    547 # ifdef BYTE_SWAP
    548       if (!nativeOrder) { SWAP_DBLE; }
    549 # endif
    550     }
    551   }
    552   if (!strcmp (outtype, "float") && !strcmp (intype, "short")) {
    553     int NbytesIn = 2;
    554     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    555       *(float *)Pout = (*(short *)Pin - Bzero) / Bscale;
    556 # ifdef BYTE_SWAP
    557       if (!nativeOrder) { SWAP_WORD; }
    558 # endif
    559     }
    560   }
    561   if (!strcmp (outtype, "double") && !strcmp (intype, "short")) {
    562     int NbytesIn = 2;
    563     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    564       *(double *)Pout = (*(short *)Pin - Bzero) / Bscale;
    565 # ifdef BYTE_SWAP
    566       if (!nativeOrder) { SWAP_DBLE; }
    567 # endif
    568     }
    569   }
    570 
    571   /** input == int **/
    572   if (!strcmp (outtype, "char") && !strcmp (intype, "int")) {
    573     int NbytesIn = 4;
    574     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    575       *(char *)Pout = (*(int *)Pin - Bzero) / Bscale;
    576     }
    577   }
    578   if (!strcmp (outtype, "byte") && !strcmp (intype, "int")) {
    579     int NbytesIn = 4;
    580     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    581       *(char *)Pout = (*(int *)Pin - Bzero) / Bscale;
    582     }
    583   }
    584   if (!strcmp (outtype, "short") && !strcmp (intype, "int")) {
    585     int NbytesIn = 4;
    586     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    587       *(short *)Pout = (*(int *)Pin - Bzero) / Bscale;
    588 # ifdef BYTE_SWAP
    589       if (!nativeOrder) { SWAP_BYTE; }
    590 # endif
    591     } 
    592   }
    593   if (!strcmp (outtype, "int") && !strcmp (intype, "int")) {
    594     int NbytesIn = 4;
    595     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    596       *(int *)Pout = (*(int *)Pin - Bzero) / Bscale;
    597 # ifdef BYTE_SWAP
    598       if (!nativeOrder) { SWAP_WORD; }
    599 # endif
    600     }
    601   }
    602   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "int")) {
    603     int NbytesIn = 4;
    604     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    605       *(int64_t *)Pout = (*(int *)Pin - Bzero) / Bscale;
    606 # ifdef BYTE_SWAP
    607       if (!nativeOrder) { SWAP_DBLE; }
    608 # endif
    609     }
    610   }
    611   if (!strcmp (outtype, "float") && !strcmp (intype, "int")) {
    612     int NbytesIn = 4;
    613     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    614       *(float *)Pout = (*(int *)Pin - Bzero) / Bscale;
    615 # ifdef BYTE_SWAP
    616       if (!nativeOrder) { SWAP_WORD; }
    617 # endif
    618     }
    619   }
    620   if (!strcmp (outtype, "double") && !strcmp (intype, "int")) {
    621     int NbytesIn = 4;
    622     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    623       *(double *)Pout = (*(int *)Pin - Bzero) / Bscale;
    624 # ifdef BYTE_SWAP
    625       if (!nativeOrder) { SWAP_DBLE; }
    626 # endif
    627     }
    628   }
    629 
    630   /** input == int64_t **/
    631   if (!strcmp (outtype, "char") && !strcmp (intype, "int64_t")) {
    632     int NbytesIn = 8;
    633     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    634       *(char *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    635     }
    636   }
    637   if (!strcmp (outtype, "byte") && !strcmp (intype, "int64_t")) {
    638     int NbytesIn = 8;
    639     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    640       *(char *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    641     }
    642   }
    643   if (!strcmp (outtype, "short") && !strcmp (intype, "int64_t")) {
    644     int NbytesIn = 8;
    645     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    646       *(short *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    647 # ifdef BYTE_SWAP
    648       if (!nativeOrder) { SWAP_BYTE; }
    649 # endif
    650     } 
    651   }
    652   if (!strcmp (outtype, "int") && !strcmp (intype, "int64_t")) {
    653     int NbytesIn = 8;
    654     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    655       *(int *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    656 # ifdef BYTE_SWAP
    657       if (!nativeOrder) { SWAP_WORD; }
    658 # endif
    659     }
    660   }
    661   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "int64_t")) {
    662     int NbytesIn = 8;
    663     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    664       *(int64_t *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    665 # ifdef BYTE_SWAP
    666       if (!nativeOrder) { SWAP_DBLE; }
    667 # endif
    668     }
    669   }
    670   if (!strcmp (outtype, "float") && !strcmp (intype, "int64_t")) {
    671     int NbytesIn = 8;
    672     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    673       *(float *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    674 # ifdef BYTE_SWAP
    675       if (!nativeOrder) { SWAP_WORD; }
    676 # endif
    677     }
    678   }
    679   if (!strcmp (outtype, "double") && !strcmp (intype, "int64_t")) {
    680     int NbytesIn = 8;
    681     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    682       *(double *)Pout = (*(int64_t *)Pin - Bzero) / Bscale;
    683 # ifdef BYTE_SWAP
    684       if (!nativeOrder) { SWAP_DBLE; }
    685 # endif
    686     }
    687   }
    688 
    689   /** input == float **/
    690   if (!strcmp (outtype, "char") && !strcmp (intype, "float")) {
    691     int NbytesIn = 4;
    692     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    693       *(char *)Pout = (*(float *)Pin - Bzero) / Bscale;
    694     }
    695   }
    696   if (!strcmp (outtype, "byte") && !strcmp (intype, "float")) {
    697     int NbytesIn = 4;
    698     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    699       *(char *)Pout = (*(float *)Pin - Bzero) / Bscale;
    700     }
    701   }
    702   if (!strcmp (outtype, "short") && !strcmp (intype, "float")) {
    703     int NbytesIn = 4;
    704     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    705       *(short *)Pout = (*(float *)Pin - Bzero) / Bscale;
    706 # ifdef BYTE_SWAP
    707       if (!nativeOrder) { SWAP_BYTE; }
    708 # endif
    709     } 
    710   }
    711   if (!strcmp (outtype, "int") && !strcmp (intype, "float")) {
    712     int NbytesIn = 4;
    713     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    714       *(int *)Pout = (*(float *)Pin - Bzero) / Bscale;
    715 # ifdef BYTE_SWAP
    716       if (!nativeOrder) { SWAP_WORD; }
    717 # endif
    718     }
    719   }
    720   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "float")) {
    721     int NbytesIn = 4;
    722     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    723       *(int64_t *)Pout = (*(float *)Pin - Bzero) / Bscale;
    724 # ifdef BYTE_SWAP
    725       if (!nativeOrder) { SWAP_DBLE; }
    726 # endif
    727     }
    728   }
    729   if (!strcmp (outtype, "float") && !strcmp (intype, "float")) {
    730     int NbytesIn = 4;
    731     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    732       *(float *)Pout = (*(float *)Pin - Bzero) / Bscale;
    733 # ifdef BYTE_SWAP
    734       if (!nativeOrder) { SWAP_WORD; }
    735 # endif
    736     }
    737   }
    738   if (!strcmp (outtype, "double") && !strcmp (intype, "float")) {
    739     int NbytesIn = 4;
    740     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    741       *(double *)Pout = (*(float *)Pin - Bzero) / Bscale;
    742 # ifdef BYTE_SWAP
    743       if (!nativeOrder) { SWAP_DBLE; }
    744 # endif
    745     }
    746   }
    747 
    748   /** input == double **/
    749   if (!strcmp (outtype, "char") && !strcmp (intype, "double")) {
    750     int NbytesIn = 8;
    751     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    752       *(char *)Pout = (*(double *)Pin - Bzero) / Bscale;
    753     }
    754   }
    755   if (!strcmp (outtype, "byte") && !strcmp (intype, "double")) {
    756     int NbytesIn = 8;
    757     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    758       *(char *)Pout = (*(double *)Pin - Bzero) / Bscale;
    759     }
    760   }
    761   if (!strcmp (outtype, "short") && !strcmp (intype, "double")) {
    762     int NbytesIn = 8;
    763     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    764       *(short *)Pout = (*(double *)Pin - Bzero) / Bscale;
    765 # ifdef BYTE_SWAP
    766       if (!nativeOrder) { SWAP_BYTE; }
    767 # endif
    768     } 
    769   }
    770   if (!strcmp (outtype, "int") && !strcmp (intype, "double")) {
    771     int NbytesIn = 8;
    772     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    773       *(int *)Pout = (*(double *)Pin - Bzero) / Bscale;
    774 # ifdef BYTE_SWAP
    775       if (!nativeOrder) { SWAP_WORD; }
    776 # endif
    777     }
    778   }
    779   if (!strcmp (outtype, "int64_t") && !strcmp (intype, "double")) {
    780     int NbytesIn = 8;
    781     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    782       *(int64_t *)Pout = (*(double *)Pin - Bzero) / Bscale;
    783 # ifdef BYTE_SWAP
    784       if (!nativeOrder) { SWAP_DBLE; }
    785 # endif
    786     }
    787   }
    788   if (!strcmp (outtype, "float") && !strcmp (intype, "double")) {
    789     int NbytesIn = 8;
    790     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    791       *(float *)Pout = (*(double *)Pin - Bzero) / Bscale;
    792 # ifdef BYTE_SWAP
    793       if (!nativeOrder) { SWAP_WORD; }
    794 # endif
    795     }
    796   }
    797   if (!strcmp (outtype, "double") && !strcmp (intype, "double")) {
    798     int NbytesIn = 8;
    799     for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) {
    800       *(double *)Pout = (*(double *)Pin - Bzero) / Bscale;
    801 # ifdef BYTE_SWAP
    802       if (!nativeOrder) { SWAP_DBLE; }
    803 # endif
    804     }
    805   }
    806 # endif
    807 
    808395  /* check array space */
    809396  if (Nx*Ny < Nx*(Nrow - 1) + Nstart + Nval*NbytesOut) {
    … …  
    813400
    814401  /* insert bytes from array into appropriate section of buffer */
    815   Pout = table[0].buffer + Nstart;
     402  Pout = table[0].buffer + Nstart + element*NbytesOut;
    816403  Pin  = array;
    817   for (i = 0; i < Nrow; i++, Pout += Nx, Pin += Nval*NbytesOut) {
    818     memcpy (Pout, Pin, Nval*NbytesOut);
     404  for (i = 0; i < Nrow; i++, Pout += Nx, Pin += NbytesOut) {
     405    memcpy (Pout, Pin, NbytesOut);
    819406  }
    820407
Note: See TracChangeset for help on using the changeset viewer.