ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rmatrix.c
(Generate patch)

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.81 by greg, Thu Jun 6 16:46:31 2024 UTC vs.
Revision 2.82 by greg, Thu Jun 6 17:01:05 2024 UTC

# Line 50 | Line 50 | rmx_prepare(RMATRIX *rm)
50                  return(1);
51          if ((rm->nrows <= 0) | (rm->ncols <= 0) | (rm->ncomp <= 0))
52                  return(0);
53 <        rm->mtx = (double *)malloc(rmx_array_size(rm));
53 >        rm->mtx = (rmx_dtype *)malloc(rmx_array_size(rm));
54          rm->pflags |= RMF_FREEMEM;
55          return(rm->mtx != NULL);
56   }
# Line 190 | Line 190 | get_dminfo(char *s, void *p)
190   }
191  
192   static int
193 < rmx_load_ascii(double *drp, const RMATRIX *rm, FILE *fp)
193 > rmx_load_ascii(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
194   {
195          int     j, k;
196  
# Line 202 | Line 202 | rmx_load_ascii(double *drp, const RMATRIX *rm, FILE *f
202   }
203  
204   static int
205 < rmx_load_float(double *drp, const RMATRIX *rm, FILE *fp)
205 > rmx_load_float(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
206   {
207          int     j, k;
208          float   val[100];
# Line 223 | Line 223 | rmx_load_float(double *drp, const RMATRIX *rm, FILE *f
223   }
224  
225   static int
226 < rmx_load_double(double *drp, const RMATRIX *rm, FILE *fp)
226 > rmx_load_double(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
227   {
228 –        if (DTrmx_native != DTdouble)
229 –                return(0);
228          if (getbinary(drp, sizeof(*drp)*rm->ncomp, rm->ncols, fp) != rm->ncols)
229                  return(0);
230          if (rm->pflags & RMF_SWAPIN)
# Line 235 | Line 233 | rmx_load_double(double *drp, const RMATRIX *rm, FILE *
233   }
234  
235   static int
236 < rmx_load_rgbe(double *drp, const RMATRIX *rm, FILE *fp)
236 > rmx_load_rgbe(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
237   {
238          COLR    *scan;
239          COLOR   col;
# Line 258 | Line 256 | rmx_load_rgbe(double *drp, const RMATRIX *rm, FILE *fp
256   }
257  
258   static int
259 < rmx_load_spec(double *drp, const RMATRIX *rm, FILE *fp)
259 > rmx_load_spec(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
260   {
261          uby8    *scan;
262          SCOLOR  scol;
# Line 311 | Line 309 | rmx_load_header(RMATRIX *rm, FILE *fp)
309          return(1);
310   }
311  
312 < /* Load next row as double (cannot be XML) */
312 > /* Load next row as rmx_dtype (cannot be XML) */
313   int
314 < rmx_load_row(double *drp, const RMATRIX *rm, FILE *fp)
314 > rmx_load_row(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
315   {
316          switch (rm->dtype) {
317          case DTascii:
# Line 342 | Line 340 | rmx_load_data(RMATRIX *rm, FILE *fp)
340          long    pos;            /* map memory for file > 1MB if possible */
341          if ((rm->dtype == DTrmx_native) & !(rm->pflags & RMF_SWAPIN) &
342                          (rmx_array_size(rm) >= 1L<<20) &&
343 <                        (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
343 >                        (pos = ftell(fp)) >= 0 && !(pos % sizeof(rmx_dtype))) {
344                  rm->mapped = mmap(NULL, rmx_array_size(rm)+pos, PROT_READ|PROT_WRITE,
345                                          MAP_PRIVATE, fileno(fp), 0);
346                  if (rm->mapped != MAP_FAILED) {
347                          if (rm->pflags & RMF_FREEMEM)
348                                  free(rm->mtx);
349 <                        rm->mtx = (double *)rm->mapped + pos/sizeof(double);
349 >                        rm->mtx = (rmx_dtype *)rm->mapped + pos/sizeof(rmx_dtype);
350                          rm->pflags &= ~RMF_FREEMEM;
351                          return(1);
352                  }               /* else fall back on reading into memory */
# Line 456 | Line 454 | rmx_load(const char *inspec, RMPref rmp)
454   }
455  
456   static int
457 < rmx_write_ascii(const double *dp, int nc, int len, FILE *fp)
457 > rmx_write_ascii(const rmx_dtype *dp, int nc, int len, FILE *fp)
458   {
459          while (len-- > 0) {
460                  int     k = nc;
# Line 468 | Line 466 | rmx_write_ascii(const double *dp, int nc, int len, FIL
466   }
467  
468   static int
469 < rmx_write_float(const double *dp, int len, FILE *fp)
469 > rmx_write_float(const rmx_dtype *dp, int len, FILE *fp)
470   {
471          float   val;
472  
# Line 481 | Line 479 | rmx_write_float(const double *dp, int len, FILE *fp)
479   }
480  
481   static int
482 < rmx_write_rgbe(const double *dp, int nc, int len, FILE *fp)
482 > rmx_write_rgbe(const rmx_dtype *dp, int nc, int len, FILE *fp)
483   {
484          COLR    *scan;
485          int     j;
# Line 500 | Line 498 | rmx_write_rgbe(const double *dp, int nc, int len, FILE
498   }
499  
500   static int
501 < rmx_write_spec(const double *dp, int nc, int len, FILE *fp)
501 > rmx_write_spec(const rmx_dtype *dp, int nc, int len, FILE *fp)
502   {
503          uby8    *scan;
504          SCOLOR  scol;
# Line 588 | Line 586 | rmx_write_header(const RMATRIX *rm, int dtype, FILE *f
586  
587   /* Write out matrix data (usually by row) */
588   int
589 < rmx_write_data(const double *dp, int nc, int len, int dtype, FILE *fp)
589 > rmx_write_data(const rmx_dtype *dp, int nc, int len, int dtype, FILE *fp)
590   {
591          switch (dtype) {
592          case DTascii:
# Line 648 | Line 646 | rmx_identity(const int dim, const int n)
646                  return(NULL);
647          memset(rid->mtx, 0, rmx_array_size(rid));
648          for (i = dim; i--; ) {
649 <            double      *dp = rmx_lval(rid,i,i);
649 >            rmx_dtype   *dp = rmx_lval(rid,i,i);
650              for (k = n; k--; )
651                  dp[k] = 1.;
652          }
# Line 742 | Line 740 | rmx_transpose(const RMATRIX *rm)
740          for (j = dnew->ncols; j--; )
741              for (i = dnew->nrows; i--; )
742                  memcpy(rmx_lval(dnew,i,j), rmx_val(rm,j,i),
743 <                                sizeof(double)*dnew->ncomp);
743 >                                sizeof(rmx_dtype)*dnew->ncomp);
744          return(dnew);
745   }
746  
# Line 767 | Line 765 | rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
765          for (i = mres->nrows; i--; )
766              for (j = mres->ncols; j--; )
767                  for (k = mres->ncomp; k--; ) {
768 <                    double      d = 0;
768 >                    rmx_dtype   d = 0;
769                      for (h = m1->ncols; h--; )
770                          d += rmx_val(m1,i,h)[k] * rmx_val(m2,h,j)[k];
771                      rmx_lval(mres,i,j)[k] = d;
# Line 795 | Line 793 | rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide
793          for (i = m1->nrows; i--; )
794              for (j = m1->ncols; j--; )
795                  if (divide) {
796 <                    double      d;
796 >                    rmx_dtype   d;
797                      if (m2->ncomp == 1) {
798                          d = rmx_val(m2,i,j)[0];
799                          if (d == 0) {
# Line 818 | Line 816 | rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide
816                          }
817                  } else {
818                      if (m2->ncomp == 1) {
819 <                        const double    d = rmx_val(m2,i,j)[0];
819 >                        const rmx_dtype d = rmx_val(m2,i,j)[0];
820                          for (k = m1->ncomp; k--; )
821                              rmx_lval(m1,i,j)[k] *= d;
822                      } else
# Line 859 | Line 857 | rmx_sum(RMATRIX *msum, const RMATRIX *madd, const doub
857                  rmx_addinfo(msum, rmx_mismatch_warn);
858          for (i = msum->nrows; i--; )
859              for (j = msum->ncols; j--; ) {
860 <                const double    *da = rmx_val(madd,i,j);
861 <                double          *ds = rmx_lval(msum,i,j);
860 >                const rmx_dtype *da = rmx_val(madd,i,j);
861 >                rmx_dtype       *ds = rmx_lval(msum,i,j);
862                  for (k = msum->ncomp; k--; )
863                       ds[k] += sf[k] * da[k];
864              }
# Line 879 | Line 877 | rmx_scale(RMATRIX *rm, const double sf[])
877                  return(0);
878          for (i = rm->nrows; i--; )
879              for (j = rm->ncols; j--; ) {
880 <                double  *dp = rmx_lval(rm,i,j);
880 >                rmx_dtype       *dp = rmx_lval(rm,i,j);
881                  for (k = rm->ncomp; k--; )
882                      dp[k] *= sf[k];
883              }
# Line 911 | Line 909 | rmx_transform(const RMATRIX *msrc, int n, const double
909          dnew->dtype = msrc->dtype;
910          for (i = dnew->nrows; i--; )
911              for (j = dnew->ncols; j--; ) {
912 <                const double    *ds = rmx_val(msrc,i,j);
912 >                const rmx_dtype *ds = rmx_val(msrc,i,j);
913                  for (kd = dnew->ncomp; kd--; ) {
914 <                    double      d = 0;
914 >                    rmx_dtype   d = 0;
915                      for (ks = msrc->ncomp; ks--; )
916                          d += cmat[kd*msrc->ncomp + ks] * ds[ks];
917                      rmx_lval(dnew,i,j)[kd] = d;
# Line 938 | Line 936 | rmx_from_cmatrix(const CMATRIX *cm)
936          for (i = dnew->nrows; i--; )
937              for (j = dnew->ncols; j--; ) {
938                  const COLORV    *cv = cm_lval(cm,i,j);
939 <                double          *dp = rmx_lval(dnew,i,j);
939 >                rmx_dtype       *dp = rmx_lval(dnew,i,j);
940                  dp[0] = cv[0];
941                  dp[1] = cv[1];
942                  dp[2] = cv[2];
# Line 960 | Line 958 | cm_from_rmatrix(const RMATRIX *rm)
958                  return(NULL);
959          for (i = cnew->nrows; i--; )
960              for (j = cnew->ncols; j--; ) {
961 <                const double    *dp = rmx_val(rm,i,j);
961 >                const rmx_dtype *dp = rmx_val(rm,i,j);
962                  COLORV          *cv = cm_lval(cnew,i,j);
963                  switch (rm->ncomp) {
964                  case 3:

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines