src/complex.c

   1 /*
   2  * complex.c:  A quick library for complex math.
   3  *
   4  * Author:
   5  *  Morten Welinder <terra@gnome.org>
   6  *  Jukka-Pekka Iivonen <iivonen@iki.fi>
   7  */
   8
   9 #include <gnumeric-config.h>
  10 #include <gnumeric.h>
  11 #include <complex.h>
  12 #include <gutils.h>
  13
  14 #include <stdlib.h>
  15 #include <errno.h>
  16 #include <mathfunc.h>
  17 #include <sf-gamma.h>
  18
  19 /* ------------------------------------------------------------------------- */
  20
  21 char *
  22 gnm_complex_to_string (gnm_complex const *src, char imunit)
  23 {
  24         char *re_buffer = NULL;
  25         char *im_buffer = NULL;
  26         char const *sign = "";
  27         char const *suffix = "";
  28         char *res;
  29         char suffix_buffer[2];
  30         const char *fmt = "%.*" GNM_FORMAT_g;
  31         static int digits = -1;
  32
  33         if (digits == -1) {
  34                 gnm_float l10 = gnm_log10 (FLT_RADIX);
  35                 digits = (int)gnm_ceil (GNM_MANT_DIG * l10) +
  36                         (l10 == (int)l10 ? 0 : 1);
  37         }
  38
  39         if (src->re != 0 || src->im == 0) {
  40                 /* We have a real part.  */
  41                 re_buffer = g_strdup_printf (fmt, digits, src->re);
  42         }
  43
  44         if (src->im != 0) {
  45                 /* We have an imaginary part.  */
  46                 suffix = suffix_buffer;
  47                 suffix_buffer[0] = imunit;
  48                 suffix_buffer[1] = 0;
  49                 if (src->im == 1) {
  50                         if (re_buffer)
  51                                 sign = "+";
  52                 } else if (src->im == -1) {
  53                         sign = "-";
  54                 } else {
  55                         im_buffer = g_strdup_printf (fmt, digits, src->im);
  56                         if (re_buffer && *im_buffer != '-' && *im_buffer != '+')
  57                                 sign = (src->im >= 0) ? "+" : "-";
  58                 }
  59         }
  60
  61         res = g_strconcat (re_buffer ? re_buffer : "",
  62                            sign,
  63                            im_buffer ? im_buffer : "",
  64                            suffix,
  65                            NULL);
  66
  67         g_free (re_buffer);
  68         g_free (im_buffer);
  69
  70         return res;
  71 }
  72
  73 /* ------------------------------------------------------------------------- */
  74
  75 #define EAT_SPACES(src_) do {                                   \
  76         while (g_unichar_isspace (g_utf8_get_char (src_)))      \
  77                 src_ = g_utf8_next_char (src_);                 \
  78 } while (0)
  79
  80 #define HANDLE_SIGN(src_,sign_) do {                            \
  81         switch (*src_) {                                        \
  82         case '+': sign_ = +1; src_++; EAT_SPACES (src_); break; \
  83         case '-': sign_ = -1; src_++; EAT_SPACES (src_); break; \
  84         default: sign_ = 0; break;                              \
  85         }                                                       \
  86 } while (0)
  87
  88 /**
  89  * gnm_complex_from_string:
  90  * @dst: return location
  91  * @src: string to parse
  92  * @imunit: (out): return location of imaginary unit.
  93  *
  94  * Returns: zero on success, -1 otherwise.
  95  *
  96  * This function differs from Excel's parsing in at least the following
  97  * ways:
  98  * (1) We allow spaces before the imaginary unit used with an impled "1".
  99  * Therefore we allow "+ i".
 100  * (2) We do not allow a thousands separator as in "1,000i".
 101  */
 102 int
 103 gnm_complex_from_string (gnm_complex *dst, char const *src, char *imunit)
 104 {
 105         gnm_float x, y;
 106         char *end;
 107         int sign;
 108
 109         EAT_SPACES (src);
 110         HANDLE_SIGN (src, sign);
 111
 112         /* Case: "i", "+i", "-i", ...  */
 113         if (*src == 'i' || *src == 'j') {
 114                 x = 1;
 115         } else {
 116                 x = gnm_strto (src, &end);
 117                 if (src == end || errno == ERANGE)
 118                         return -1;
 119                 src = end;
 120                 EAT_SPACES (src);
 121         }
 122         if (sign < 0)
 123                 x = 0 - x;
 124
 125         /* Case: "42", "+42", "-42", ...  */
 126         if (*src == 0) {
 127                 *dst = GNM_CREAL (x);
 128                 *imunit = 'i';
 129                 return 0;
 130         }
 131
 132         /* Case: "42i", "+42i", "-42i", "-i", "i", ...  */
 133         if (*src == 'i' || *src == 'j') {
 134                 *imunit = *src++;
 135                 EAT_SPACES (src);
 136                 if (*src == 0) {
 137                         *dst = GNM_CMAKE (0, x);
 138                         return 0;
 139                 } else
 140                         return -1;
 141         }
 142
 143         HANDLE_SIGN (src, sign);
 144         if (!sign)
 145                 return -1;
 146
 147         if (*src == 'i' || *src == 'j') {
 148                 y = 1;
 149         } else {
 150                 y = gnm_strto (src, &end);
 151                 if (src == end || errno == ERANGE)
 152                         return -1;
 153                 src = end;
 154                 EAT_SPACES (src);
 155         }
 156         if (sign < 0)
 157                 y = 0 - y;
 158
 159         /* Case: "42+12i", "+42-12i", "-42-12i", "-42+i", "+42-i", ...  */
 160         if (*src == 'i' || *src == 'j') {
 161                 *imunit = *src++;
 162                 EAT_SPACES (src);
 163                 if (*src == 0) {
 164                         *dst = GNM_CMAKE (x, y);
 165                         return 0;
 166                 }
 167         }
 168
 169         return -1;
 170 }
 171
 172 /* ------------------------------------------------------------------------- */
 173
 174 int
 175 gnm_complex_invalid_p (gnm_complex const *src)
 176 {
 177         return !(gnm_finite (src->re) && gnm_finite (src->im));
 178 }
 179
 180 /* ------------------------------------------------------------------------- */