libgfortran/generated/norm2_r10.c

   1 /* Implementation of the NORM2 intrinsic
   2    Copyright 2010 Free Software Foundation, Inc.
   3    Contributed by Tobias Burnus  <burnus@net-b.de>
   4
   5 This file is part of the GNU Fortran runtime library (libgfortran).
   6
   7 Libgfortran is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU General Public
   9 License as published by the Free Software Foundation; either
  10 version 3 of the License, or (at your option) any later version.
  11
  12 Libgfortran is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 Under Section 7 of GPL version 3, you are granted additional
  18 permissions described in the GCC Runtime Library Exception, version
  19 3.1, as published by the Free Software Foundation.
  20
  21 You should have received a copy of the GNU General Public License and
  22 a copy of the GCC Runtime Library Exception along with this program;
  23 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "libgfortran.h"
  27 #include <stdlib.h>
  28 #include <math.h>
  29 #include <assert.h>
  30
  31
  32
  33 #if defined (HAVE_GFC_REAL_10) && defined (HAVE_GFC_REAL_10) && defined (HAVE_SQRTL) && defined (HAVE_FABSL)
  34
  35 #define MATHFUNC(funcname) funcname ## l
  36 #define BUILTINMATHFUNC(funcname) MATHFUNC(funcname)
  37
  38
  39 extern void norm2_r10 (gfc_array_r10 * const restrict,
  40         gfc_array_r10 * const restrict, const index_type * const restrict);
  41 export_proto(norm2_r10);
  42
  43 void
  44 norm2_r10 (gfc_array_r10 * const restrict retarray,
  45         gfc_array_r10 * const restrict array,
  46         const index_type * const restrict pdim)
  47 {
  48   index_type count[GFC_MAX_DIMENSIONS];
  49   index_type extent[GFC_MAX_DIMENSIONS];
  50   index_type sstride[GFC_MAX_DIMENSIONS];
  51   index_type dstride[GFC_MAX_DIMENSIONS];
  52   const GFC_REAL_10 * restrict base;
  53   GFC_REAL_10 * restrict dest;
  54   index_type rank;
  55   index_type n;
  56   index_type len;
  57   index_type delta;
  58   index_type dim;
  59   int continue_loop;
  60
  61   /* Make dim zero based to avoid confusion.  */
  62   dim = (*pdim) - 1;
  63   rank = GFC_DESCRIPTOR_RANK (array) - 1;
  64
  65   len = GFC_DESCRIPTOR_EXTENT(array,dim);
  66   if (len < 0)
  67     len = 0;
  68   delta = GFC_DESCRIPTOR_STRIDE(array,dim);
  69
  70   for (n = 0; n < dim; n++)
  71     {
  72       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
  73       extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
  74
  75       if (extent[n] < 0)
  76         extent[n] = 0;
  77     }
  78   for (n = dim; n < rank; n++)
  79     {
  80       sstride[n] = GFC_DESCRIPTOR_STRIDE(array, n + 1);
  81       extent[n] = GFC_DESCRIPTOR_EXTENT(array, n + 1);
  82
  83       if (extent[n] < 0)
  84         extent[n] = 0;
  85     }
  86
  87   if (retarray->data == NULL)
  88     {
  89       size_t alloc_size, str;
  90
  91       for (n = 0; n < rank; n++)
  92         {
  93           if (n == 0)
  94             str = 1;
  95           else
  96             str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
  97
  98           GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
  99
 100         }
 101
 102       retarray->offset = 0;
 103       retarray->dtype = (array->dtype & ~GFC_DTYPE_RANK_MASK) | rank;
 104
 105       alloc_size = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(retarray,rank-1)
 106                    * extent[rank-1];
 107
 108       if (alloc_size == 0)
 109         {
 110           /* Make sure we have a zero-sized array.  */
 111           GFC_DIMENSION_SET(retarray->dim[0], 0, -1, 1);
 112           return;
 113
 114         }
 115       else
 116         retarray->data = internal_malloc_size (alloc_size);
 117     }
 118   else
 119     {
 120       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 121         runtime_error ("rank of return array incorrect in"
 122                        " NORM intrinsic: is %ld, should be %ld",
 123                        (long int) (GFC_DESCRIPTOR_RANK (retarray)),
 124                        (long int) rank);
 125
 126       if (unlikely (compile_options.bounds_check))
 127         bounds_ifunction_return ((array_t *) retarray, extent,
 128                                  "return value", "NORM");
 129     }
 130
 131   for (n = 0; n < rank; n++)
 132     {
 133       count[n] = 0;
 134       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
 135       if (extent[n] <= 0)
 136         len = 0;
 137     }
 138
 139   base = array->data;
 140   dest = retarray->data;
 141
 142   continue_loop = 1;
 143   while (continue_loop)
 144     {
 145       const GFC_REAL_10 * restrict src;
 146       GFC_REAL_10 result;
 147       src = base;
 148       {
 149
 150         GFC_REAL_10 scale;
 151         result = 0;
 152         scale = 1;
 153         if (len <= 0)
 154           *dest = 0;
 155         else
 156           {
 157             for (n = 0; n < len; n++, src += delta)
 158               {
 159
 160           if (*src != 0)
 161             {
 162               GFC_REAL_10 absX, val;
 163               absX = MATHFUNC(fabs) (*src);
 164               if (scale < absX)
 165                 {
 166                   val = scale / absX;
 167                   result = 1 + result * val * val;
 168                   scale = absX;
 169                 }
 170               else
 171                 {
 172                   val = absX / scale;
 173                   result += val * val;
 174                 }
 175             }
 176               }
 177             result = scale * MATHFUNC(sqrt) (result);
 178             *dest = result;
 179           }
 180       }
 181       /* Advance to the next element.  */
 182       count[0]++;
 183       base += sstride[0];
 184       dest += dstride[0];
 185       n = 0;
 186       while (count[n] == extent[n])
 187         {
 188           /* When we get to the end of a dimension, reset it and increment
 189              the next dimension.  */
 190           count[n] = 0;
 191           /* We could precalculate these products, but this is a less
 192              frequently used path so probably not worth it.  */
 193           base -= sstride[n] * extent[n];
 194           dest -= dstride[n] * extent[n];
 195           n++;
 196           if (n == rank)
 197             {
 198               /* Break out of the look.  */
 199               continue_loop = 0;
 200               break;
 201             }
 202           else
 203             {
 204               count[n]++;
 205               base += sstride[n];
 206               dest += dstride[n];
 207             }
 208         }
 209     }
 210 }
 211
 212 #endif