Chris@10: /*
Chris@10:  * Copyright (c) 2003, 2007-11 Matteo Frigo
Chris@10:  * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
Chris@10:  *
Chris@10:  * This program is free software; you can redistribute it and/or modify
Chris@10:  * it under the terms of the GNU General Public License as published by
Chris@10:  * the Free Software Foundation; either version 2 of the License, or
Chris@10:  * (at your option) any later version.
Chris@10:  *
Chris@10:  * This program is distributed in the hope that it will be useful,
Chris@10:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
Chris@10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Chris@10:  * GNU General Public License for more details.
Chris@10:  *
Chris@10:  * You should have received a copy of the GNU General Public License
Chris@10:  * along with this program; if not, write to the Free Software
Chris@10:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
Chris@10:  *
Chris@10:  */
Chris@10: 
Chris@10: 
Chris@10: #include "ifftw.h"
Chris@10: 
Chris@10: static int signof(INT x)
Chris@10: {
Chris@10:      if (x < 0) return -1;
Chris@10:      if (x == 0) return 0;
Chris@10:      /* if (x > 0) */ return 1;
Chris@10: }
Chris@10: 
Chris@10: /* total order among iodim's */
Chris@10: int X(dimcmp)(const iodim *a, const iodim *b)
Chris@10: {
Chris@10:      INT sai = X(iabs)(a->is), sbi = X(iabs)(b->is);
Chris@10:      INT sao = X(iabs)(a->os), sbo = X(iabs)(b->os);
Chris@10:      INT sam = X(imin)(sai, sao), sbm = X(imin)(sbi, sbo);
Chris@10: 
Chris@10:      /* in descending order of min{istride, ostride} */
Chris@10:      if (sam != sbm)
Chris@10: 	  return signof(sbm - sam);
Chris@10: 
Chris@10:      /* in case of a tie, in descending order of istride */
Chris@10:      if (sbi != sai)
Chris@10:           return signof(sbi - sai);
Chris@10: 
Chris@10:      /* in case of a tie, in descending order of ostride */
Chris@10:      if (sbo != sao)
Chris@10:           return signof(sbo - sao);
Chris@10: 
Chris@10:      /* in case of a tie, in ascending order of n */
Chris@10:      return signof(a->n - b->n);
Chris@10: }
Chris@10: 
Chris@10: static void canonicalize(tensor *x)
Chris@10: {
Chris@10:      if (x->rnk > 1) {
Chris@10: 	  qsort(x->dims, (size_t)x->rnk, sizeof(iodim),
Chris@10: 		(int (*)(const void *, const void *))X(dimcmp));
Chris@10:      }
Chris@10: }
Chris@10: 
Chris@10: static int compare_by_istride(const iodim *a, const iodim *b)
Chris@10: {
Chris@10:      INT sai = X(iabs)(a->is), sbi = X(iabs)(b->is);
Chris@10: 
Chris@10:      /* in descending order of istride */
Chris@10:      return signof(sbi - sai);
Chris@10: }
Chris@10: 
Chris@10: static tensor *really_compress(const tensor *sz)
Chris@10: {
Chris@10:      int i, rnk;
Chris@10:      tensor *x;
Chris@10: 
Chris@10:      A(FINITE_RNK(sz->rnk));
Chris@10:      for (i = rnk = 0; i < sz->rnk; ++i) {
Chris@10:           A(sz->dims[i].n > 0);
Chris@10:           if (sz->dims[i].n != 1)
Chris@10:                ++rnk;
Chris@10:      }
Chris@10: 
Chris@10:      x = X(mktensor)(rnk);
Chris@10:      for (i = rnk = 0; i < sz->rnk; ++i) {
Chris@10:           if (sz->dims[i].n != 1)
Chris@10:                x->dims[rnk++] = sz->dims[i];
Chris@10:      }
Chris@10:      return x;
Chris@10: }
Chris@10: 
Chris@10: /* Like tensor_copy, but eliminate n == 1 dimensions, which
Chris@10:    never affect any transform or transform vector.
Chris@10:  
Chris@10:    Also, we sort the tensor into a canonical order of decreasing
Chris@10:    strides (see X(dimcmp) for an exact definition).  In general,
Chris@10:    processing a loop/array in order of decreasing stride will improve
Chris@10:    locality.  Both forward and backwards traversal of the tensor are
Chris@10:    considered e.g. by vrank-geq1, so sorting in increasing
Chris@10:    vs. decreasing order is not really important. */
Chris@10: tensor *X(tensor_compress)(const tensor *sz)
Chris@10: {
Chris@10:      tensor *x = really_compress(sz);
Chris@10:      canonicalize(x);
Chris@10:      return x;
Chris@10: }
Chris@10: 
Chris@10: /* Return whether the strides of a and b are such that they form an
Chris@10:    effective contiguous 1d array.  Assumes that a.is >= b.is. */
Chris@10: static int strides_contig(iodim *a, iodim *b)
Chris@10: {
Chris@10:      return (a->is == b->is * b->n && a->os == b->os * b->n);
Chris@10: }
Chris@10: 
Chris@10: /* Like tensor_compress, but also compress into one dimension any
Chris@10:    group of dimensions that form a contiguous block of indices with
Chris@10:    some stride.  (This can safely be done for transform vector sizes.) */
Chris@10: tensor *X(tensor_compress_contiguous)(const tensor *sz)
Chris@10: {
Chris@10:      int i, rnk;
Chris@10:      tensor *sz2, *x;
Chris@10: 
Chris@10:      if (X(tensor_sz)(sz) == 0) 
Chris@10: 	  return X(mktensor)(RNK_MINFTY);
Chris@10: 
Chris@10:      sz2 = really_compress(sz);
Chris@10:      A(FINITE_RNK(sz2->rnk));
Chris@10: 
Chris@10:      if (sz2->rnk <= 1) { /* nothing to compress. */ 
Chris@10: 	  if (0) {
Chris@10: 	       /* this call is redundant, because "sz->rnk <= 1" implies
Chris@10: 		  that the tensor is already canonical, but I am writing
Chris@10: 		  it explicitly because "logically" we need to canonicalize
Chris@10: 		  the tensor before returning. */
Chris@10: 	       canonicalize(sz2);
Chris@10: 	  }
Chris@10:           return sz2;
Chris@10:      }
Chris@10: 
Chris@10:      /* sort in descending order of |istride|, so that compressible
Chris@10: 	dimensions appear contigously */
Chris@10:      qsort(sz2->dims, (size_t)sz2->rnk, sizeof(iodim),
Chris@10: 		(int (*)(const void *, const void *))compare_by_istride);
Chris@10: 
Chris@10:      /* compute what the rank will be after compression */
Chris@10:      for (i = rnk = 1; i < sz2->rnk; ++i)
Chris@10:           if (!strides_contig(sz2->dims + i - 1, sz2->dims + i))
Chris@10:                ++rnk;
Chris@10: 
Chris@10:      /* merge adjacent dimensions whenever possible */
Chris@10:      x = X(mktensor)(rnk);
Chris@10:      x->dims[0] = sz2->dims[0];
Chris@10:      for (i = rnk = 1; i < sz2->rnk; ++i) {
Chris@10:           if (strides_contig(sz2->dims + i - 1, sz2->dims + i)) {
Chris@10:                x->dims[rnk - 1].n *= sz2->dims[i].n;
Chris@10:                x->dims[rnk - 1].is = sz2->dims[i].is;
Chris@10:                x->dims[rnk - 1].os = sz2->dims[i].os;
Chris@10:           } else {
Chris@10:                A(rnk < x->rnk);
Chris@10:                x->dims[rnk++] = sz2->dims[i];
Chris@10:           }
Chris@10:      }
Chris@10: 
Chris@10:      X(tensor_destroy)(sz2);
Chris@10: 
Chris@10:      /* reduce to canonical form */
Chris@10:      canonicalize(x);
Chris@10:      return x;
Chris@10: }
Chris@10: 
Chris@10: /* The inverse of X(tensor_append): splits the sz tensor into
Chris@10:    tensor a followed by tensor b, where a's rank is arnk. */
Chris@10: void X(tensor_split)(const tensor *sz, tensor **a, int arnk, tensor **b)
Chris@10: {
Chris@10:      A(FINITE_RNK(sz->rnk) && FINITE_RNK(arnk));
Chris@10: 
Chris@10:      *a = X(tensor_copy_sub)(sz, 0, arnk);
Chris@10:      *b = X(tensor_copy_sub)(sz, arnk, sz->rnk - arnk);
Chris@10: }
Chris@10: 
Chris@10: /* TRUE if the two tensors are equal */
Chris@10: int X(tensor_equal)(const tensor *a, const tensor *b)
Chris@10: {
Chris@10:      if (a->rnk != b->rnk)
Chris@10: 	  return 0;
Chris@10: 
Chris@10:      if (FINITE_RNK(a->rnk)) {
Chris@10: 	  int i;
Chris@10: 	  for (i = 0; i < a->rnk; ++i) 
Chris@10: 	       if (0
Chris@10: 		   || a->dims[i].n != b->dims[i].n
Chris@10: 		   || a->dims[i].is != b->dims[i].is
Chris@10: 		   || a->dims[i].os != b->dims[i].os
Chris@10: 		    )
Chris@10: 		    return 0;
Chris@10:      }
Chris@10: 
Chris@10:      return 1;
Chris@10: }
Chris@10: 
Chris@10: /* TRUE if the sets of input and output locations described by
Chris@10:    (append sz vecsz) are the same */
Chris@10: int X(tensor_inplace_locations)(const tensor *sz, const tensor *vecsz)
Chris@10: {
Chris@10:      tensor *t = X(tensor_append)(sz, vecsz);
Chris@10:      tensor *ti = X(tensor_copy_inplace)(t, INPLACE_IS);
Chris@10:      tensor *to = X(tensor_copy_inplace)(t, INPLACE_OS);
Chris@10:      tensor *tic = X(tensor_compress_contiguous)(ti);
Chris@10:      tensor *toc = X(tensor_compress_contiguous)(to);
Chris@10: 
Chris@10:      int retval = X(tensor_equal)(tic, toc);
Chris@10: 
Chris@10:      X(tensor_destroy)(t);
Chris@10:      X(tensor_destroy4)(ti, to, tic, toc);
Chris@10: 
Chris@10:      return retval;
Chris@10: }