libgfortran/generated/norm2_r17.c

   1 /* Implementation of the NORM2 intrinsic
   2    Copyright (C) 2010-2023 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
  28
  29
  30 #if defined (HAVE_GFC_REAL_17) && defined (HAVE_GFC_REAL_17) && 1 /* FIXME: figure this out later.  */ && 1 /* FIXME: figure this out later.  */
  31
  32 #if defined(POWER_IEEE128)
  33 #define MATHFUNC(funcname) __ ## funcname ## ieee128
  34 #elif defined(GFC_REAL_17_USE_IEC_60559)
  35 #define MATHFUNC(funcname) funcname ## f128
  36 #else
  37 #define MATHFUNC(funcname) funcname ## q
  38 #endif
  39
  40
  41 extern void norm2_r17 (gfc_array_r17 * const restrict,
  42         gfc_array_r17 * const restrict, const index_type * const restrict);
  43 export_proto(norm2_r17);
  44
  45 void
  46 norm2_r17 (gfc_array_r17 * const restrict retarray,
  47         gfc_array_r17 * const restrict array,
  48         const index_type * const restrict pdim)
  49 {
  50   index_type count[GFC_MAX_DIMENSIONS];
  51   index_type extent[GFC_MAX_DIMENSIONS];
  52   index_type sstride[GFC_MAX_DIMENSIONS];
  53   index_type dstride[GFC_MAX_DIMENSIONS];
  54   const GFC_REAL_17 * restrict base;
  55   GFC_REAL_17 * restrict dest;
  56   index_type rank;
  57   index_type n;
  58   index_type len;
  59   index_type delta;
  60   index_type dim;
  61   int continue_loop;
  62
  63   /* Make dim zero based to avoid confusion.  */
  64   rank = GFC_DESCRIPTOR_RANK (array) - 1;
  65   dim = (*pdim) - 1;
  66
  67   if (unlikely (dim < 0 || dim > rank))
  68     {
  69       runtime_error ("Dim argument incorrect in NORM intrinsic: "
  70                      "is %ld, should be between 1 and %ld",
  71                      (long int) dim + 1, (long int) rank + 1);
  72     }
  73
  74   len = GFC_DESCRIPTOR_EXTENT(array,dim);
  75   if (len < 0)
  76     len = 0;
  77   delta = GFC_DESCRIPTOR_STRIDE(array,dim);
  78
  79   for (n = 0; n < dim; n++)
  80     {
  81       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
  82       extent[n] = GFC_DESCRIPTOR_EXTENT(array,n);
  83
  84       if (extent[n] < 0)
  85         extent[n] = 0;
  86     }
  87   for (n = dim; n < rank; n++)
  88     {
  89       sstride[n] = GFC_DESCRIPTOR_STRIDE(array, n + 1);
  90       extent[n] = GFC_DESCRIPTOR_EXTENT(array, n + 1);
  91
  92       if (extent[n] < 0)
  93         extent[n] = 0;
  94     }
  95
  96   if (retarray->base_addr == NULL)
  97     {
  98       size_t alloc_size, str;
  99
 100       for (n = 0; n < rank; n++)
 101         {
 102           if (n == 0)
 103             str = 1;
 104           else
 105             str = GFC_DESCRIPTOR_STRIDE(retarray,n-1) * extent[n-1];
 106
 107           GFC_DIMENSION_SET(retarray->dim[n], 0, extent[n] - 1, str);
 108
 109         }
 110
 111       retarray->offset = 0;
 112       retarray->dtype.rank = rank;
 113
 114       alloc_size = GFC_DESCRIPTOR_STRIDE(retarray,rank-1) * extent[rank-1];
 115
 116       retarray->base_addr = xmallocarray (alloc_size, sizeof (GFC_REAL_17));
 117       if (alloc_size == 0)
 118         {
 119           /* Make sure we have a zero-sized array.  */
 120           GFC_DIMENSION_SET(retarray->dim[0], 0, -1, 1);
 121           return;
 122
 123         }
 124     }
 125   else
 126     {
 127       if (rank != GFC_DESCRIPTOR_RANK (retarray))
 128         runtime_error ("rank of return array incorrect in"
 129                        " NORM intrinsic: is %ld, should be %ld",
 130                        (long int) (GFC_DESCRIPTOR_RANK (retarray)),
 131                        (long int) rank);
 132
 133       if (unlikely (compile_options.bounds_check))
 134         bounds_ifunction_return ((array_t *) retarray, extent,
 135                                  "return value", "NORM");
 136     }
 137
 138   for (n = 0; n < rank; n++)
 139     {
 140       count[n] = 0;
 141       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
 142       if (extent[n] <= 0)
 143         return;
 144     }
 145
 146   base = array->base_addr;
 147   dest = retarray->base_addr;
 148
 149   continue_loop = 1;
 150   while (continue_loop)
 151     {
 152       const GFC_REAL_17 * restrict src;
 153       GFC_REAL_17 result;
 154       src = base;
 155       {
 156
 157         GFC_REAL_17 scale;
 158         result = 0;
 159         scale = 1;
 160         if (len <= 0)
 161           *dest = 0;
 162         else
 163           {
 164 #if ! defined HAVE_BACK_ARG
 165             for (n = 0; n < len; n++, src += delta)
 166               {
 167 #endif
 168
 169           if (*src != 0)
 170             {
 171               GFC_REAL_17 absX, val;
 172               absX = MATHFUNC(fabs) (*src);
 173               if (scale < absX)
 174                 {
 175                   val = scale / absX;
 176                   result = 1 + result * val * val;
 177                   scale = absX;
 178                 }
 179               else
 180                 {
 181                   val = absX / scale;
 182                   result += val * val;
 183                 }
 184             }
 185               }
 186             result = scale * MATHFUNC(sqrt) (result);
 187             *dest = result;
 188           }
 189       }
 190       /* Advance to the next element.  */
 191       count[0]++;
 192       base += sstride[0];
 193       dest += dstride[0];
 194       n = 0;
 195       while (count[n] == extent[n])
 196         {
 197           /* When we get to the end of a dimension, reset it and increment
 198              the next dimension.  */
 199           count[n] = 0;
 200           /* We could precalculate these products, but this is a less
 201              frequently used path so probably not worth it.  */
 202           base -= sstride[n] * extent[n];
 203           dest -= dstride[n] * extent[n];
 204           n++;
 205           if (n >= rank)
 206             {
 207               /* Break out of the loop.  */
 208               continue_loop = 0;
 209               break;
 210             }
 211           else
 212             {
 213               count[n]++;
 214               base += sstride[n];
 215               dest += dstride[n];
 216             }
 217         }
 218     }
 219 }
 220
 221 #endif