author: kx <kx@radix-linux.su> 2024-12-20 16:11:07 +0300
committer: kx <kx@radix-linux.su> 2024-12-20 16:11:07 +0300
commit: 868b2b66b564b5c00e3a74d10be45db7151627ac
parent: cce2ae8d3312493b7653358bb4af201d3271377b
Commit Summary:
Diffstat:
1 file changed, 8058 insertions, 0 deletions
diff --git a/mpu/mpu-tetrade.c b/mpu/mpu-tetrade.c
new file mode 100644
index 0000000..147fd3c
--- /dev/null
+++ b/mpu/mpu-tetrade.c
@@ -0,0 +1,10553 @@
+
+/***************************************************************
+ __MPU_TETRADE.C
+
+ This file containt source code of of function
+ for arithmetic & mathematic operations.
+
+ PART OF : MPU - library .
+
+ USAGE : Internal only .
+
+ NOTE : NONE .
+
+ Copyright (C) 2000 - 2024 by Andrew V.Kosteltsev.
+ All Rights Reserved.
+ ***************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h> /* errno(3) */
+#include <string.h> /* strcpy(3) */
+#include <strings.h> /* bzero(3) */
+#include <stdlib.h>
+
+#include <libmpu.h>
+#include <mpu-context.h>
+
+#include <mpu-emutype.h>
+#include <mpu-integer.h>
+#include <mpu-real.h>
+#include <mpu-floatp.h>
+#include <mpu-ioreal.h>
+#include <mpu-m-const.h>
+#include <mpu-math.h>
+
+#include <mpu-char.h>
+#include <mpu-symbols.h>
+
+#include <mpu-math-errno.h>
+#include <mpu-strerror.h>
+#include <mpu-mtherr.h>
+
+
+/***************************************************************
+ INTEGER ARITHMETIC OPERATIONS
+ ***************************************************************/
+
+
+/***************************************************************
+ Операции ложения и вычитания [ c = a + b; c = a - b; ]
+ Воздействуют на флаги: AF, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void iadd( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* сложение знаковое и беззнаковое целых всех размеров */
+/*
+ c = a + b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iadd_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ iadd_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ iadd_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ iadd_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b,nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iadd() */
+
+
+void iadc( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* сложение знаковое и беззнаковое целых всех размеров с переносом */
+/*
+ c = a + b with carry;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iadc_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ iadc_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ iadc_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ iadc_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iadc() */
+
+
+void isub( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* вычитание знаковое и беззнаковое целых всех размеров */
+/*
+ c = a - b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isub_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ isub_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ isub_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ isub_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isub() */
+
+
+void isbb( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* вычитание знаковое и беззнаковое целых всех размеров с переносом */
+/*
+ c = a - b with carry;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isbb_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ isbb_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ isbb_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ isbb_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isbb() */
+
+
+/***************************************************************
+ Операции сдвига на 1 бит [c = <<a; c = >>a;]
+ Воздействуют на флаги: AF=0, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void ishl( mpu_int *c, mpu_int *a, int nb )
+/* Логический беззнаковый сдвиг влево на один бит */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ishl_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ ishl_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ ishl_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ ishl_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ishl() */
+
+
+void ishr( mpu_int *c, mpu_int *a, int nb )
+/* Логический беззнаковый сдвиг вправо на один бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ishr_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ ishr_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ ishr_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ ishr_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ishr() */
+
+
+void isal( mpu_int *c, mpu_int *a, int nb )
+/* Арифметический сдвиг влево на один бит */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isal_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ isal_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ isal_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ isal_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isal() */
+
+
+void isar( mpu_int *c, mpu_int *a, int nb )
+/* Арифметический сдвиг вправо на один бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isar_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ isar_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ isar_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ isar_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isar() */
+
+
+/***************************************************************
+ Операции иклических сдвигов на 1 бит
+ Воздействуют на флаги: AF=0, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void irol( mpu_int *c, mpu_int *a, int nb )
+/* Циклический сдвиг влево на один бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ irol_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ irol_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ irol_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ irol_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End irol() */
+
+
+void iror( mpu_int *c, mpu_int *a, int nb )
+/* Циклический сдвиг вправо на один бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iror_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ iror_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ iror_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ iror_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iror() */
+
+
+void ircl( mpu_int *c, mpu_int *a, int nb )
+/* Циклический сдвиг влево на один бит с переносом */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ircl_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ ircl_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ ircl_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ ircl_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ircl() */
+
+
+void ircr( mpu_int *c, mpu_int *a, int nb )
+/* Циклический сдвиг вправо на один бит с переносом */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ircr_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ ircr_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ ircr_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ ircr_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ircr() */
+
+
+/***************************************************************
+ Операции сдвига на (ns) бит
+ Воздействует на флаги: AF=0, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void ishln( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Логический сдвиг влево на (ns) бит */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ishln_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ ishln_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ ishln_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ ishln_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ishln() */
+
+
+void ishrn( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Логический сдвиг вправо на (ns) бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ishrn_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ ishrn_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ ishrn_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ ishrn_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ishrn() */
+
+
+void isaln( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Арифметический сдвиг влево на (ns) бит */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isaln_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ isaln_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ isaln_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ isaln_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isaln() */
+
+
+void isarn( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Арифметический сдвиг вправо на (ns) бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isarn_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ isarn_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ isarn_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ isarn_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isarn() */
+
+
+/***************************************************************
+ Операции иклических сдвигов на (ns) бит.
+ Воздействует на флаги: AF=0, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void iroln( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Циклический сдвиг влево на (ns) бит */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iroln_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ iroln_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ iroln_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ iroln_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iroln() */
+
+
+void irorn( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Циклический сдвиг вправо на (ns) бит */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ irorn_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ irorn_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ irorn_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ irorn_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End irorn() */
+
+
+void ircln( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Циклический сдвиг влево на (ns) бит с переносом */
+/*
+ c = <<a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ircln_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ ircln_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ ircln_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ ircln_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ircln() */
+
+
+void ircrn( mpu_int *c, mpu_int *a, unsigned int ns, int nb )
+/* Циклический сдвиг вправо на (ns) бит с переносом */
+/*
+ c = >>a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ircrn_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a, ns );
+ break;
+
+ case 2:
+ ircrn_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a, ns );
+ break;
+
+ case 4:
+ ircrn_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a, ns );
+ break;
+
+ default:
+ ircrn_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, ns, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ircrn() */
+
+
+/***************************************************************
+ Операция NOT [c = (инверсия всех разрядов)a].
+ На флаги не воздействует.
+ ***************************************************************/
+void inot( mpu_int *c, mpu_int *a, int nb )
+/* поразрядное логическое НЕ */
+/*
+ c = ~a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ inot_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ inot_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ inot_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ inot_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End inot() */
+
+
+/***************************************************************
+ Операция NEG [c = - a].
+ Воздействует на флаги: AF, CF, OF, PF, SF, ZF.
+ ***************************************************************/
+void ineg( mpu_int *c, mpu_int *a, int nb )
+/*
+ c = -a;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ineg_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ ineg_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ ineg_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ ineg_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ineg() */
+
+
+/***************************************************************
+ Операция AND [c = a <AND> b].
+ Воздействует на флаги: AF=(undefined),
+ CF=0, OF=0, PF, SF, ZF.
+ ***************************************************************/
+void iand( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* поразрядное логическое И */
+/*
+ c = a & b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iand_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ iand_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ iand_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ iand_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iand() */
+
+
+
+/***************************************************************
+ Операция TEST [a <TEST> b]. Не изменяет значения операндов.
+ Воздействует на флаги: AF=(undefined),
+ CF=0, OF=0, PF, SF, ZF.
+ ***************************************************************/
+void itest( mpu_int *a, mpu_int *b, int nb )
+/* поразрядное логическое И */
+/*
+ a & b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ itest_8( (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ itest_16( (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ itest_32( (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ itest_np( (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End itest() */
+
+
+/***************************************************************
+ Операция сравнения CMP [<a - b>].
+ Не изменяет значения операндов.
+ Выставляет флаги: AF, CF, OF, SF, PF, ZF.
+ ***************************************************************/
+void icmp( mpu_int *a, mpu_int *b, int nb )
+/*
+ a - b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ icmp_8( (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ icmp_16( (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ icmp_32( (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ icmp_np( (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End icmp() */
+
+
+/***************************************************************
+ Операция OR [c = a <OR> b].
+ Воздействует на флаги: AF=(undefined),
+ CF=0, OF=0, PF, SF, ZF.
+ ***************************************************************/
+void ior( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* поразрядное логическое ИЛИ */
+/*
+ c = a | b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ior_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ ior_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ ior_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ ior_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ior() */
+
+
+/***************************************************************
+ Операция XOR [c = a <XOR> b].
+ Воздействует на флаги: AF=(undefined),
+ CF=0, OF=0, PF, SF, ZF.
+ ***************************************************************/
+void ixor( mpu_int *c, mpu_int *a, mpu_int *b, int nb )
+/* поразрядное логическое исключающее ИЛИ */
+/*
+ c = a ^ b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ixor_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ ixor_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ ixor_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ ixor_np( (EMUSHORT *)c,
+ (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ixor() */
+
+
+/***************************************************************
+ Операция INC (инкремент) [c = a + 1].
+ Воздействует на флаги: AF, OF, PF, SF, ZF.
+ Флаг CF не изменяется.
+ ***************************************************************/
+void iinc( mpu_int *c, mpu_int *a, int nb )
+/*
+ c = a + 1;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iinc_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ iinc_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ iinc_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ iinc_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iinc() */
+
+
+/***************************************************************
+ Операция DEC (декремент) [c = a - 1].
+ Воздействует на флаги: AF, OF, PF, SF, ZF.
+ Флаг CF не изменяется.
+ ***************************************************************/
+void idec( mpu_int *c, mpu_int *a, int nb )
+/*
+ c = a - 1;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ idec_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ idec_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ idec_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ idec_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End idec() */
+
+
+/***************************************************************
+ Операция XCHG (замена) [a <==> b].
+ Не изменяет флаги.
+ ***************************************************************/
+void ixchg( mpu_int *a, mpu_int *b, int nb )
+/*
+ a <==> b;
+ *****************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ixchg_8( (__mpu_uint8_t *)a,
+ (__mpu_uint8_t *)b );
+ break;
+
+ case 2:
+ ixchg_16( (__mpu_uint16_t *)a,
+ (__mpu_uint16_t *)b );
+ break;
+
+ case 4:
+ ixchg_32( (__mpu_uint32_t *)a,
+ (__mpu_uint32_t *)b );
+ break;
+
+ default:
+ ixchg_np( (EMUSHORT *)a,
+ (EMUSHORT *)b, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ixchg() */
+
+
+/***************************************************************
+ Операция копирования данных CPY.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***************************************************************/
+void icpy( mpu_int *c, mpu_int *a, int nb_c, int nb_a )
+/*
+ c <-- a;
+ **********/
+{
+ int np_c, np_a;
+
+ __integer_error_no = 0;
+
+ np_c = nb_c / SIZE_OF_EMUSHORT;
+ np_a = nb_a / SIZE_OF_EMUSHORT;
+
+ if( nb_c == nb_a ) /* копирование равных */
+ {
+ switch( nb_a )
+ {
+ case 1:
+ icpy_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ icpy_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ icpy_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icpy_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nd_c == nb_a ) */
+
+ } /* End if( nb_c == nb_a ) */
+ else if( nb_c > nb_a ) /* копирование меньших в большие */
+ {
+ switch( nb_a )
+ {
+ case 1: /* копирование байта */
+ switch( nb_c )
+ {
+ case 2: /* в два байта */
+ icpy_s2l_8to16( (__mpu_uint16_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 4: /* в четыре байта */
+ icpy_s2l_8to32( (__mpu_uint32_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ default:
+ icpy_s2l_8to_np( (EMUSHORT *)c,
+ (__mpu_uint8_t *)a, np_c );
+ break;
+ }
+ break;
+
+ case 2: /* копирование двух байт */
+ switch( nb_c )
+ {
+ case 4: /* в четыре байта */
+ icpy_s2l_16to32( (__mpu_uint32_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ default:
+ icpy_s2l_16to_np( (EMUSHORT *)c,
+ (__mpu_uint16_t *)a, np_c );
+ break;
+ }
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4: /* копирование четырех байт */
+ icpy_s2l_32to_np( (EMUSHORT *)c,
+ (__mpu_uint32_t *)a, np_c );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ icpy_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nb_a ) */
+
+ } /* End if( nb_c > nb_a ) */
+ else /* копирование больших в меньшие */
+ {
+ switch( nb_c )
+ {
+ case 1: /* копирование в байт */
+ switch( nb_a )
+ {
+ case 2: /* двух байт */
+ icpy_l2s_16to8( (__mpu_uint8_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4: /* четырх байт */
+ icpy_l2s_32to8( (__mpu_uint8_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icpy_l2s_np_to8( (__mpu_uint8_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+ }
+ break;
+
+ case 2: /* копирование в два байта */
+ switch( nb_a )
+ {
+ case 4: /* четырех байт */
+ icpy_l2s_32to16( (__mpu_uint16_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icpy_l2s_np_to16( (__mpu_uint16_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+ }
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4: /* копирование в четыре байта */
+ icpy_l2s_np_to32( (__mpu_uint32_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ icpy_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nb_c ) */
+
+ } /* End ( nb_c < nb_a ) */
+
+} /* End of icpy() */
+
+
+/***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***************************************************************/
+void icvt( mpu_int *c, mpu_int *a, int nb_c, int nb_a )
+/*
+ c <-- a;
+ **********/
+{
+ int np_c, np_a;
+
+ __integer_error_no = 0;
+
+ np_c = nb_c / SIZE_OF_EMUSHORT;
+ np_a = nb_a / SIZE_OF_EMUSHORT;
+
+ if( nb_c == nb_a ) /* конвертирование равных */
+ {
+ switch( nb_a )
+ {
+ case 1:
+ icpy_8( (__mpu_uint8_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 2:
+ icpy_16( (__mpu_uint16_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4:
+ icpy_32( (__mpu_uint32_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icpy_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nd_c == nb_a ) */
+
+ } /* End if( nb_c == nb_a ) */
+ else if( nb_c > nb_a ) /* конвертирование меньших в большие */
+ {
+ switch( nb_a )
+ {
+ case 1: /* конвертирование байта */
+ switch( nb_c )
+ {
+ case 2: /* в два байта */
+ icvt_s2l_8to16( (__mpu_uint16_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ case 4: /* в четыре байта */
+ icvt_s2l_8to32( (__mpu_uint32_t *)c,
+ (__mpu_uint8_t *)a );
+ break;
+
+ default:
+ icvt_s2l_8to_np( (EMUSHORT *)c,
+ (__mpu_uint8_t *)a, np_c );
+ break;
+ }
+ break;
+
+ case 2: /* конвертирование двух байт */
+ switch( nb_c )
+ {
+ case 4: /* в четыре байта */
+ icvt_s2l_16to32( (__mpu_uint32_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ default:
+ icvt_s2l_16to_np( (EMUSHORT *)c,
+ (__mpu_uint16_t *)a, np_c );
+ break;
+ }
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4: /* конвертирование четырех байт */
+ icvt_s2l_32to_np( (EMUSHORT *)c,
+ (__mpu_uint32_t *)a, np_c );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ icvt_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nb_a ) */
+
+ } /* End if( nb_c > nb_a ) */
+ else /* конвертирование больших в меньшие */
+ {
+ switch( nb_c )
+ {
+ case 1: /* конвертирование в байт */
+ switch( nb_a )
+ {
+ case 2: /* двух байт */
+ icvt_l2s_16to8( (__mpu_uint8_t *)c,
+ (__mpu_uint16_t *)a );
+ break;
+
+ case 4: /* четырх байт */
+ icvt_l2s_32to8( (__mpu_uint8_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icvt_l2s_np_to8( (__mpu_uint8_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+ }
+ break;
+
+ case 2: /* конвертирование в два байта */
+ switch( nb_a )
+ {
+ case 4: /* четырех байт */
+ icvt_l2s_32to16( (__mpu_uint16_t *)c,
+ (__mpu_uint32_t *)a );
+ break;
+
+ default:
+ icvt_l2s_np_to16( (__mpu_uint16_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+ }
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4: /* конвертирование в четыре байта */
+ icvt_l2s_np_to32( (__mpu_uint32_t *)c,
+ (EMUSHORT *)a, np_a );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ icvt_np( (EMUSHORT *)c,
+ (EMUSHORT *)a, np_c, np_a );
+ break;
+
+ } /* End of switch( nb_c ) */
+
+ } /* End ( nb_c < nb_a ) */
+
+} /* End of icvt() */
+
+
+/***************************************************************
+ Операции беззнакового и знакового умножения.
+ [ prod = num * mul; ]
+ Изменяет флаги: CF, AF=0, PF, ZF, SF, OF, RF.
+ ***************************************************************/
+void imul( mpu_int *prod, mpu_int *num, mpu_int *mul, int nb_prod, int nb_num )
+/* prod - произведение */
+/* num - множимое */
+/* mul - множитель */
+/* nb_prod - размер произведения */
+/* nb_num - размер множимого */
+/* Операция беззнакового умножения MUL */
+/*
+ prod = num * mul; nb_prod == 2*nb_num;
+ ****************************************/
+{
+ __integer_error_no = 0;
+
+ if( nb_prod < 2*nb_num )
+ {
+ /* error: Invalid size of operand(s) */
+ __integer_invalid_size( (__mpu_char8_t *)"imul" );
+ return;
+ }
+
+ switch( nb_num ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ imul_8( (__mpu_uint16_t *)prod,
+ (__mpu_uint8_t *)num,
+ (__mpu_uint8_t *)mul );
+ break;
+
+ case 2:
+ imul_16( (__mpu_uint32_t *)prod,
+ (__mpu_uint16_t *)num,
+ (__mpu_uint16_t *)mul );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ imul_32( (__mpu_uint64_t *)prod,
+ (__mpu_uint32_t *)num,
+ (__mpu_uint32_t *)mul );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ imul_np( (EMUSHORT *)prod,
+ (EMUSHORT *)num,
+ (EMUSHORT *)mul, nb_prod/SIZE_OF_EMUSHORT,
+ nb_num/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End imul() */
+
+
+void ismul( mpu_int *prod, mpu_int *num, mpu_int *mul, int nb_prod, int nb_num )
+/* prod - произведение */
+/* num - множимое */
+/* mul - множитель */
+/* nb_prod - размер произведения */
+/* nb_num - размер множимого */
+/* Операция знакового умножения SMUL */
+/*
+ prod = num * mul; nb_prod == 2*nb_num;
+ ****************************************/
+{
+ __integer_error_no = 0;
+
+ if( nb_prod < 2*nb_num )
+ {
+ /* error: Invalid size of operand(s) */
+ __integer_invalid_size( (__mpu_char8_t *)"ismul" );
+ return;
+ }
+
+ switch( nb_num ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ ismul_8( (__mpu_uint16_t *)prod,
+ (__mpu_uint8_t *)num,
+ (__mpu_uint8_t *)mul );
+ break;
+
+ case 2:
+ ismul_16( (__mpu_uint32_t *)prod,
+ (__mpu_uint16_t *)num,
+ (__mpu_uint16_t *)mul );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ ismul_32( (__mpu_uint64_t *)prod,
+ (__mpu_uint32_t *)num,
+ (__mpu_uint32_t *)mul );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ ismul_np( (EMUSHORT *)prod,
+ (EMUSHORT *)num,
+ (EMUSHORT *)mul, nb_prod/SIZE_OF_EMUSHORT,
+ nb_num/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End ismul() */
+
+
+/***************************************************************
+ Операции беззнакового и знакового деления.
+ Изменяет флаги: CF, AF=0, PF, ZF, SF, OF, RF.
+ ***************************************************************/
+void idiv( mpu_int *quot, mpu_int *rem, mpu_int *num, mpu_int *den, int nb )
+/* quot - частное */
+/* rem - остаток */
+/* num - делимое */
+/* den - делитель */
+/* nb - размер в байтах */
+/* Операция беззнакового деления DIV */
+/*
+ quot = num / den; rem = remainder;
+ *************************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ idiv_8( (__mpu_uint8_t *)quot,
+ (__mpu_uint8_t *)rem,
+ (__mpu_uint8_t *)num,
+ (__mpu_uint8_t *)den );
+ break;
+
+ case 2:
+ idiv_16( (__mpu_uint16_t *)quot,
+ (__mpu_uint16_t *)rem,
+ (__mpu_uint16_t *)num,
+ (__mpu_uint16_t *)den );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ idiv_32( (__mpu_uint32_t *)quot,
+ (__mpu_uint32_t *)rem,
+ (__mpu_uint32_t *)num,
+ (__mpu_uint32_t *)den );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ idiv_np( (EMUSHORT *)quot,
+ (EMUSHORT *)rem,
+ (EMUSHORT *)num,
+ (EMUSHORT *)den, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End idiv() */
+
+
+void isdiv( mpu_int *quot, mpu_int *rem, mpu_int *num, mpu_int *den, int nb )
+/* quot - частное */
+/* rem - остаток */
+/* num - делимое */
+/* den - делитель */
+/* nb - размер в байтах */
+/* Операция знакового деления SDIV */
+/*
+ quot = num / den; rem = remainder;
+ ************************************/
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ isdiv_8( (__mpu_uint8_t *)quot,
+ (__mpu_uint8_t *)rem,
+ (__mpu_uint8_t *)num,
+ (__mpu_uint8_t *)den );
+ break;
+
+ case 2:
+ isdiv_16( (__mpu_uint16_t *)quot,
+ (__mpu_uint16_t *)rem,
+ (__mpu_uint16_t *)num,
+ (__mpu_uint16_t *)den );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ isdiv_32( (__mpu_uint32_t *)quot,
+ (__mpu_uint32_t *)rem,
+ (__mpu_uint32_t *)num,
+ (__mpu_uint32_t *)den );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ isdiv_np( (EMUSHORT *)quot,
+ (EMUSHORT *)rem,
+ (EMUSHORT *)num,
+ (EMUSHORT *)den, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End isdiv() */
+
+
+/***************************************************************
+ Операции преобразования символьных строк в целые числа.
+ Изменяет флаги: CF=0, AF=0, PF, ZF, SF, OF. Не изменяет: RF.
+ ***************************************************************/
+/*
+ signed
+ ********/
+void iatoi( mpu_int *c, __mpu_char8_t *str, int nb )
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iatoi_8( (__mpu_uint8_t *)c, str );
+ break;
+
+ case 2:
+ iatoi_16( (__mpu_uint16_t *)c, str );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ iatoi_32( (__mpu_uint32_t *)c, str );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ iatoi_np( (EMUSHORT *)c, str, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iatoi() */
+
+/*
+ unsigned
+ **********/
+void iatoui( mpu_int *c, __mpu_char8_t *str, int nb )
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iatoui_8( (__mpu_uint8_t *)c, str );
+ break;
+
+ case 2:
+ iatoui_16( (__mpu_uint16_t *)c, str );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ iatoui_32( (__mpu_uint32_t *)c, str );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ iatoui_np( (EMUSHORT *)c, str, nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iatoui() */
+
+
+/***************************************************************
+ Операции преобразования целых чисел в символьные строки.
+ Не изменяет флаги: CF, AF, PF, ZF, SF, OF, RF.
+ ***************************************************************/
+/* radix = 2(bin), 8(oct), 10(dec), or 16(hex). */
+/* uf = 0(lowercase letter) or
+ 1(uppercase letter) in prefix and hex-digits. */
+/* sign = 0(' '), or 1('-'). */
+/* see tetrade.h */
+/*
+ signed
+ ********/
+void iitoa( __mpu_char8_t *str, mpu_int *a, int radix, int uf, int nb )
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iitoa_8( str, (__mpu_uint8_t *)a, radix, uf );
+ return;
+ break;
+
+ case 2:
+ iitoa_16( str, (__mpu_uint16_t *)a, radix, uf );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ iitoa_32( str, (__mpu_uint32_t *)a, radix, uf );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ iitoa_np( str,
+ (EMUSHORT *)a,
+ radix,
+ uf,
+ nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iitoa() */
+
+/*
+ unsigned
+ **********/
+void iuitoa( __mpu_char8_t *str, mpu_int *a, int radix, int uf, int nb )
+{
+ __integer_error_no = 0;
+
+ switch( nb ) /* NB is number of bytes in mpu_int's. */
+ {
+ case 1:
+ iuitoa_8( str, (__mpu_uint8_t *)a, radix, uf );
+ break;
+
+ case 2:
+ iuitoa_16( str, (__mpu_uint16_t *)a, radix, uf );
+ break;
+
+#if BITS_PER_EMUSHORT > 32
+ case 4:
+ iuitoa_32( str, (__mpu_uint32_t *)a, radix, uf );
+ break;
+#endif /* BITS_PER_EMUSHORT > 32 */
+
+ default:
+ iuitoa_np( str,
+ (EMUSHORT *)a,
+ radix,
+ uf,
+ nb/SIZE_OF_EMUSHORT );
+ break;
+
+ } /* End of switch( nb ) */
+
+} /* End iuitoa() */
+
+
+/***************************************************************
+ REAL ARITHMETIC OPERATIONS
+ ***************************************************************/
+
+/***************************************************************
+ BEGIN: mpu-floatp.h
+ */
+
+int _sizeof_exp( int nb )
+/***************************************************************
+ возвращает количество байт целого числа, в которое может
+ уместится Exponent вещественного числа размером NB байт.
+ (See: NB_R32, NB_R64, ... , NB_R_MAX in __TX_TETRADE.H).
+ ***************************************************************/
+{
+ int rc = 0;
+
+ __real_error_no = 0;
+
+ switch( nb )
+ {
+ case NB_R32:
+ rc = 1;
+ break;
+ case NB_R64:
+ rc = 2;
+ break;
+
+ case NB_R128:
+ case NB_R256:
+ rc = 4;
+ break;
+
+ case NB_R512:
+ case NB_R1024:
+ rc = 8;
+ break;
+
+ case NB_R2048:
+ case NB_R4096:
+ rc =16;
+ break;
+
+ case NB_R8192:
+ case NB_R16384:
+ rc =32;
+ break;
+
+ case NB_R32768:
+ case NB_R65536:
+ rc =64;
+ break;
+
+ default:
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_sizeof_exp" );
+ rc = -1;
+ }
+ break;
+
+ } /* End of switch( nb ) */
+
+ return( rc );
+
+} /* End of _sizeof_exp() */
+
+
+int _real_mant_digs( int nb )
+/***************************************************************
+ RETURNS: # of bits in mantissa.
+ ***************************************************************/
+{
+ int rc = 0;
+
+ __real_error_no = 0;
+
+ switch( nb )
+ {
+ case NB_R32:
+ rc = 24;
+ break;
+ case NB_R64:
+ rc = 53;
+ break;
+
+ case NB_R128: /* NOTE: +1 sign bit. */
+ rc = 97;
+ break;
+ case NB_R256:
+ rc = 225;
+ break;
+
+ case NB_R512:
+ rc = 449;
+ break;
+ case NB_R1024:
+ rc = 961;
+ break;
+
+ case NB_R2048:
+ rc = 1921;
+ break;
+ case NB_R4096:
+ rc = 3969;
+ break;
+
+ case NB_R8192:
+ rc = 7937;
+ break;
+ case NB_R16384:
+ rc = 16129;
+ break;
+
+ case NB_R32768:
+ rc = 32257;
+ break;
+ case NB_R65536:
+ rc = 65025;
+ break;
+
+ default:
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_mant_digs" );
+ rc =-1;
+ }
+ break;
+
+ } /* End of switch( nb ) */
+
+ return( rc );
+
+} /* End of _real_mant_digs() */
+
+
+int _real_digs( int nb )
+/*
+ RETURNS: # of decimal digits of precision
+ *******************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = _get_ndec( n_bits );
+
+ return( ret );
+
+} /* End of _real_digs() */
+
+
+int _real_max_string( int nb )
+/*
+ RETURNS: # of symbols for convert real number to string
+ *********************************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = _get_max_string( n_bits );
+
+ return( ret );
+
+} /* End of _real_max_string() */
+
+
+void _real_epsilon( mpu_real *c, int nb )
+/*
+ smallest such that 1.0+REAL_EPSILON != 1.0
+ ********************************************/
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_epsilon_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_epsilon() */
+
+
+void _real_max_10_exp( mpu_int *e, int nb_e, int nb_r )
+/*
+ max decimal exponent
+ **********************/
+{
+ EMUSHORT *exp = NULL;
+ int ne, n_bits, n_bytes;
+ int l;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ l = _sizeof_exp( nb_r );
+
+ if( l <= 0 )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_10_exp" );
+ return;
+ }
+
+ if( nb_e < l )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_10_exp" );
+ return;
+ }
+
+ n_bits = nb_r * BITS_PER_BYTE;
+ ne = internal_ne( n_bits ) + 1;
+ n_bytes = ne * SIZE_OF_EMUSHORT;
+
+ /*** Allocate memory for exp . ******************************/
+ exp = (EMUSHORT *)__mpu_sbrk( (int)(ne*SIZE_OF_EMUSHORT) );
+ if( !exp )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_cpye( exp, _get_max_10_exp_ptr( n_bits ), ne, ne );
+
+ /*
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( e, (mpu_int *)exp, nb_e, n_bytes );
+
+ /* FREE exp ***************/
+ __mpu_sbrk( -(int)(ne*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_max_10_exp() */
+
+
+void _real_min_10_exp( mpu_int *e, int nb_e, int nb_r )
+/*
+ min decimal exponent
+ **********************/
+{
+ EMUSHORT *exp = NULL;
+ int ne, n_bits, n_bytes;
+ int l;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ l = _sizeof_exp( nb_r );
+
+ if( l <= 0 )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_min_10_exp" );
+ return;
+ }
+
+ if( nb_e < l )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_min_10_exp" );
+ return;
+ }
+
+ n_bits = nb_r * BITS_PER_BYTE;
+ ne = internal_ne( n_bits ) + 1;
+ n_bytes = ne * SIZE_OF_EMUSHORT;
+
+ /*** Allocate memory for exp . ******************************/
+ exp = (EMUSHORT *)__mpu_sbrk( (int)(ne*SIZE_OF_EMUSHORT) );
+ if( !exp )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_cpye( exp, _get_min_10_exp_ptr( n_bits ), ne, ne );
+
+ /*
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( e, (mpu_int *)exp, nb_e, n_bytes );
+
+ /* FREE exp ***************/
+ __mpu_sbrk( -(int)(ne*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_min_10_exp() */
+
+
+void _real_max_max_exp( mpu_int *e, int nb_e, int nb_r )
+/*
+ max max binary exponent
+ *************************/
+{
+ EMUSHORT *exp = NULL;
+ int ne, n_bits, n_bytes;
+ int l;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ l = _sizeof_exp( nb_r );
+
+ if( l <= 0 )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_max_exp" );
+ return;
+ }
+
+ if( nb_e < l )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_max_exp" );
+ return;
+ }
+
+ n_bits = nb_r * BITS_PER_BYTE;
+ ne = internal_ne( n_bits ) + 1;
+ n_bytes = ne * SIZE_OF_EMUSHORT;
+
+ /*** Allocate memory for exp . ******************************/
+ exp = (EMUSHORT *)__mpu_sbrk( (int)(ne*SIZE_OF_EMUSHORT) );
+ if( !exp )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_cpye( exp, _get_max_max_2_exp_ptr( n_bits ), ne, ne );
+
+ /*
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( e, (mpu_int *)exp, nb_e, n_bytes );
+
+ /* FREE exp ***************/
+ __mpu_sbrk( -(int)(ne*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_max_max_exp() */
+
+
+void _real_max_exp( mpu_int *e, int nb_e, int nb_r )
+/*
+ max binary exponent ( EXONE )
+ *******************************/
+{
+ EMUSHORT *exp = NULL;
+ int ne, n_bits, n_bytes;
+ int l;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ l = _sizeof_exp( nb_r );
+
+ if( l <= 0 )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_exp" );
+ return;
+ }
+
+ if( nb_e < l )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_max_exp" );
+ return;
+ }
+
+ n_bits = nb_r * BITS_PER_BYTE;
+ ne = internal_ne( n_bits ) + 1;
+ n_bytes = ne * SIZE_OF_EMUSHORT;
+
+ /*** Allocate memory for exp . ******************************/
+ exp = (EMUSHORT *)__mpu_sbrk( (int)(ne*SIZE_OF_EMUSHORT) );
+ if( !exp )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_cpye( exp, _get_max_2_exp_ptr( n_bits ), ne, ne );
+
+ /*
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( e, (mpu_int *)exp, nb_e, n_bytes );
+
+ /* FREE exp ***************/
+ __mpu_sbrk( -(int)(ne*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_max_exp() */
+
+
+void _real_min_exp( mpu_int *e, int nb_e, int nb_r )
+/*
+ min binary exponent
+ *********************/
+{
+ EMUSHORT *exp = NULL;
+ int ne, n_bits, n_bytes;
+ int l;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ l = _sizeof_exp( nb_r );
+
+ if( l <= 0 )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_min_exp" );
+ return;
+ }
+
+ if( nb_e < l )
+ {
+ /* error: Invalid size of operand(s) */
+ __real_invalid_size( (__mpu_char8_t *)"_real_min_exp" );
+ return;
+ }
+
+ n_bits = nb_r * BITS_PER_BYTE;
+ ne = internal_ne( n_bits ) + 1;
+ n_bytes = ne * SIZE_OF_EMUSHORT;
+
+ /*** Allocate memory for exp . ******************************/
+ exp = (EMUSHORT *)__mpu_sbrk( (int)(ne*SIZE_OF_EMUSHORT) );
+ if( !exp )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_cpye( exp, _get_min_2_exp_ptr( n_bits ), ne, ne );
+
+ /*
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( e, (mpu_int *)exp, nb_e, n_bytes );
+
+ /* FREE exp ***************/
+ __mpu_sbrk( -(int)(ne*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _real_min_exp() */
+
+/*
+ END: mpu-floatp.h
+ ***************************************************************/
+
+
+/***************************************************************
+ ARITHMETIC & MATHEMATIC CONSTANTS.
+ **/
+void _m_zero( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_zero() */
+
+
+void _m_half( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_half( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_half() */
+
+
+void _m_one( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_one( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_one() */
+
+
+void _m_two( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_two( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_two() */
+
+
+void _m_ten( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_ten( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_ten() */
+
+
+void _m_mten( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_mten( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_mten() */
+
+
+void _m_32( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ _gen_32( eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_32() */
+
+void _m_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI() */
+
+
+void _m_E( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_e_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_E() */
+
+
+void _m_1_ln2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_ln2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_ln2() */
+
+
+void _m_ln2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_ln2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_ln2() */
+
+
+void _m_1_ln10( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_ln10_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_ln10() */
+
+
+void _m_ln10( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_ln10_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_ln10() */
+
+
+void _m_1_lg2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_lg2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_lg2() */
+
+
+void _m_lg2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_lg2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_lg2() */
+
+
+void _m_PI_2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI_2() */
+
+
+void _m_PI_3( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_3_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI_3() */
+
+
+void _m_PI_4( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_4_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI_4() */
+
+
+void _m_PI_5( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_5_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI_5() */
+
+
+void _m_PI_6( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_pi_6_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_PI_6() */
+
+
+void _m_1_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_PI() */
+
+
+void _m_2_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_2_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_2_PI() */
+
+
+void _m_3_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_3_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_3_PI() */
+
+
+void _m_4_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_4_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_4_PI() */
+
+
+void _m_5_PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_5_pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_5_PI() */
+
+
+void _m_2PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_2pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_2PI() */
+
+
+void _m_3PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_3pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_3PI() */
+
+
+void _m_1_2PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_2pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_2PI() */
+
+
+void _m_1_3PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_3pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_3PI() */
+
+
+void _m_1_4PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_4pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_4PI() */
+
+
+void _m_1_5PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_5pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_5PI() */
+
+
+void _m_1_6PI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_6pi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_6PI() */
+
+
+void _m_3PI_4( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_3pi_4_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_3PI_4() */
+
+
+void _m_SQRTPI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_sqrtpi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_SQRTPI() */
+
+
+void _m_1_SQRTPI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_sqrtpi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_SQRTPI() */
+
+
+void _m_2_SQRTPI( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_2_sqrtpi_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_2_SQRTPI() */
+
+
+void _m_SQRT2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_sqrt2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_SQRT2() */
+
+
+void _m_1_SQRT2( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_sqrt2_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_SQRT2() */
+
+
+void _m_SQRT3( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_sqrt3_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_SQRT3() */
+
+
+void _m_1_SQRT3( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_sqrt3_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_SQRT3() */
+
+
+void _m_DEGREE( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_degree_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_DEGREE() */
+
+
+void _m_1_DEGREE( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_1_degree_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_1_DEGREE() */
+
+
+void _m_GOLDENRATIO( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_goldenratio_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_GOLDENRATIO() */
+
+
+void _m_EULERGAMMA( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_eulergamma_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_EULERGAMMA() */
+
+
+void _m_CATALAN( mpu_real *c, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ ei_copy( eic, _get_m_catalan_ptr( n_bits ), n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of _m_CATALAN() */
+
+/**
+ END OF ARITHMETIC & MATHEMATIC CONSTANTS.
+ ***************************************************************/
+
+
+void _ind( mpu_real *c, int nb )
+/*
+ формирует `неопределенность' (- 1.IND)
+ ****************************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_ind( (EMUSHORT *)c, n_bits );
+
+} /* End of rind() */
+
+
+int _is_ind( mpu_real *c, int nb )
+/*
+ проверка на `неопределенность' (- 1.IND)
+ ******************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isind( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_ind() */
+
+
+void _nan( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует `не число' (+/- 1.NAN)
+ которое не равно nan_max, nan_min и ind.
+ ******************************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_nan( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _nan() */
+
+
+int _is_nans( mpu_real *c, int nb )
+/*
+ проверка на `не число' (+/- 1.NAN)
+ которое не равно InD.
+ ******************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isnans( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_nans() */
+
+
+void _nan_max( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует максимальное `не число' (+/- 1.NAN)
+ которое не равно nan_min и ind.
+ ***********************************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_nanmax( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _nan_max() */
+
+
+int _is_nan_max( mpu_real *c, int nb )
+/*
+ проверка на максимальное `не число' (+/- 1.NAN)
+ которое не равно nan_min и ind.
+ *************************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isnanmax( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_nan_max() */
+
+
+void _nan_min( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует минимальное `не число' (+/- 1.NAN)
+ которое не равно nan_max и ind.
+ **********************************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_nanmin( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _nan_min() */
+
+
+int _is_nan_min( mpu_real *c, int nb )
+/*
+ проверка на минимальное `не число' (+/- 1.NAN)
+ которое не равно nan_max и ind.
+ ************************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isnanmin( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_nan_min() */
+
+
+void _inf( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует `бесконечность' (+/- 1.INF)
+ ***************************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_infin( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _inf() */
+
+
+int _is_inf( mpu_real *c, int nb )
+/*
+ проверка на `бесконечность' (+/- 1.INF)
+ *****************************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isinfin( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_inf() */
+
+
+void _real_min( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует `минимальное число'.
+ ********************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_realmin( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _real_min() */
+
+
+void _real_max( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует `максимальное число'.
+ *********************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_realmax( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _real_max() */
+
+
+void _signull( mpu_real *c, unsigned int sign, int nb )
+/*
+ формирует `знаковый нуль'.
+ ****************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_signull( (EMUSHORT *)c, sign, n_bits );
+
+} /* End of _signull() */
+
+
+int _is_signull( mpu_real *c, int nb )
+/*
+ проверка на `знаковый нуль'.
+ ******************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_issignull( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of _is_signull() */
+
+
+void r_neg( mpu_real *c, int nb )
+/*
+ negate real number.
+ *********************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_neg( (EMUSHORT *)c, n_bits );
+
+} /* End of r_neg() */
+
+
+int r_is_neg( mpu_real *c, int nb )
+/*
+ проверка на отрицательное число
+ (-0.0 здесь отрицательное число).
+ **********************************/
+{
+ int ret;
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ ret = e_isneg( (EMUSHORT *)c, n_bits );
+
+ return( ret );
+
+} /* End of r_is_neg() */
+
+
+void r_abs( mpu_real *c, int nb )
+/*
+ сбрасывает знак числа.
+ ************************/
+{
+ int n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ e_abs( (EMUSHORT *)c, n_bits );
+
+} /* End of r_abs() */
+
+
+int r_sign( mpu_real *c, int nb )
+/*
+ if( c > 0.0 ) return +1;
+ if( c < 0.0 ) return -1;
+ if( c == +-0.0 ) return 0;
+
+ if( c == NaNs || c == InD ) return -2;
+ ********************************************/
+{
+ EMUSHORT *eic = NULL,
+ *zero = NULL;
+
+ int n_bits;
+ int np;
+ int ret = -3;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, zero . ************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return( ret );
+ }
+
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( ret );
+ }
+ /************************************************************/
+
+ unpack( eic, (EMUSHORT *)c, n_bits );
+ _gen_zero( zero, n_bits );
+
+ ret = ei_cmp( eic, zero, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE zero **************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( ret );
+
+} /* End of r_sign() */
+
+
+int r_cmp( mpu_real *a, mpu_real *b, int nb )
+/*
+ if( a > b ) return +1;
+ if( a < b ) return -1;
+ if( a == b ) return 0;
+
+ if( (a || b) is NaNs || InD ) return -2;
+ ********************************************/
+{
+ EMUSHORT *eia = NULL,
+ *eib = NULL;
+
+ int n_bits;
+ int np;
+ int ret = -3;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eia, eib . *************************/
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+ return( ret );
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( ret );
+ }
+ /************************************************************/
+
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ret = ei_cmp( eia, eib, n_bits );
+
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( ret );
+
+} /* End of r_cmp() */
+
+
+void r_cpy( mpu_real *a, mpu_real *b, int nb )
+{
+ int i;
+
+ for( i = 0; i < nb; i++ ) *a++ = *b++;
+
+} /* End of r_cpy() */
+
+
+void r_cvt( mpu_real *a, mpu_real *b, int nb_a, int nb_b )
+/*
+ Convert (size type) of real number B to A.
+ ********************************************/
+{
+ EMUSHORT *eia = NULL,
+ *eib = NULL;
+ int n_bits_a, n_bits_b;
+ int np_a, np_b;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits_a = nb_a * BITS_PER_BYTE;
+ n_bits_b = nb_b * BITS_PER_BYTE;
+
+ np_a = internal_np( n_bits_a );
+ np_b = internal_np( n_bits_b );
+
+ /*** Allocate memory for eia, eib . *************************/
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np_a*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np_b*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eib, (EMUSHORT *)b, n_bits_b );
+
+ ei_convert( (EMUSHORT *)eia, (EMUSHORT *)eib, n_bits_a, n_bits_b );
+
+ pack( (EMUSHORT *)a, eia, n_bits_a );
+
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(np_b*SIZE_OF_EMUSHORT) );
+ /**************************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_cvt() */
+
+
+void r_add( mpu_real *c, mpu_real *a, mpu_real *b, int nb )
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL,
+ *eib = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia, eib . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ei_add( eic, eia, eib, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_add() */
+
+
+void r_sub( mpu_real *c, mpu_real *a, mpu_real *b, int nb )
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL,
+ *eib = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia, eib . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ei_sub( eic, eia, eib, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_sub() */
+
+
+void r_mul( mpu_real *c, mpu_real *a, mpu_real *b, int nb )
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL,
+ *eib = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia, eib . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ei_mul( eic, eia, eib, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_mul() */
+
+
+void r_div( mpu_real *c, mpu_real *a, mpu_real *b, int nb )
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL,
+ *eib = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia, eib . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ei_div( eic, eia, eib, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_div() */
+
+
+void ltor( mpu_real *r, mpu_int *l, int nb_r, int nb_l )
+/*
+ Convert long integer number L to real number R.
+ *************************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_l = NULL; /* save *l */
+ int n_bits, n_parts, bytes_in_emushort;
+ int n_bits_target;
+ int np;
+
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits_target = nb_r * BITS_PER_BYTE;
+ /******************************************************
+ Берем размер в 2 раза больший, так как для ei_ltor()
+ необходимо, чтобы размер целого был меньше мантиссы
+ вещественного.
+ ******************************************************/
+ if( nb_r == nb_l )
+ n_bits = nb_r * BITS_PER_BYTE * 2;
+ else if( nb_r < nb_l )
+ n_bits = nb_l * BITS_PER_BYTE * 2;
+ else
+ n_bits = n_bits_target;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_l . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /***********************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( (mpu_int *)p_l, l, n_parts*bytes_in_emushort, nb_l );
+
+ ei_ltor( eir, p_l, n_bits, n_parts );
+
+ /******************************************************
+ Возвращаем оригинальный размер цели
+ ******************************************************/
+ if( n_bits != n_bits_target )
+ ei_convert( eir, eir, n_bits_target, n_bits );
+
+ pack( (EMUSHORT *)r, eir, n_bits_target );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of ltor() */
+
+
+void ultor( mpu_real *r, mpu_int *l, int nb_r, int nb_l )
+/*
+ Convert long integer number L to real number R.
+ ***************************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_l = NULL; /* save *l */
+ int n_bits, n_parts, bytes_in_emushort;
+ int n_bits_target;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits_target = nb_r * BITS_PER_BYTE;
+ /******************************************************
+ Берем размер в 2 раза больший, так как для ei_ltor()
+ необходимо, чтобы размер целого был меньше мантиссы
+ вещественного.
+ ******************************************************/
+ if( nb_r == nb_l )
+ n_bits = nb_r * BITS_PER_BYTE * 2;
+ else if( nb_r < nb_l )
+ n_bits = nb_l * BITS_PER_BYTE * 2;
+ else
+ n_bits = n_bits_target;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_l . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /***********************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF.
+ Флаги CF, AF не изменяются.
+ ***********************************************/
+ icvt( (mpu_int *)p_l, l, n_parts*bytes_in_emushort, nb_l );
+
+ ei_ultor( eir, p_l, n_bits, n_parts );
+
+ /******************************************************
+ Возвращаем оригинальный размер цели
+ ******************************************************/
+ if( n_bits != n_bits_target )
+ ei_convert( eir, eir, n_bits_target, n_bits );
+
+ pack( (EMUSHORT *)r, eir, n_bits_target );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of ultor() */
+
+
+
+void rtol_frac( mpu_int *l, mpu_real *frac, mpu_real *r, int nb_l, int nb_r )
+/*
+ Convert real number R to long integer number L
+ and find floating point fractional part *FRAC.
+ FRAC my be NULL.
+ ************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_f = NULL,
+ *p_l = NULL; /* save *l */
+ int n_bits, n_parts, bytes_in_emushort;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits = nb_r * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_f, p_l . ********************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_f = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !p_f )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE p_f ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+
+ if( frac )
+ ei_rtol_frac( p_l, p_f, eir, n_parts, n_bits );
+ else
+ ei_rtol_frac( p_l, (EMUSHORT *)0, eir, n_parts, n_bits );
+
+ /***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF. Флаги CF, AF не изменяются.
+ ***************************************************************/
+ icvt( l, (mpu_int *)p_l, nb_l, n_parts*bytes_in_emushort );
+
+ if( frac ) pack( (EMUSHORT *)frac, p_f, n_bits );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eir ***************/
+ /* FREE p_f ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of rtol_frac() */
+
+
+void rtoul_frac( mpu_int *l, mpu_real *frac, mpu_real *r, int nb_l, int nb_r )
+/*
+ Convert real number R to UNSIGNED long integer number L
+ and find floating point fractional part *FRAC.
+ FRAC my be NULL.
+ *********************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_f = NULL,
+ *p_l = NULL; /* save *l */
+ int n_bits, n_parts, bytes_in_emushort;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits = nb_r * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_f, p_l . ********************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_f = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !p_f )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE p_f ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+
+ if( frac )
+ ei_rtoul_frac( p_l, p_f, eir, n_parts, n_bits );
+ else
+ ei_rtoul_frac( p_l, (EMUSHORT *)0, eir, n_parts, n_bits );
+
+ /***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF. Флаги CF, AF не изменяются.
+ ***************************************************************/
+ icvt( l, (mpu_int *)p_l, nb_l, n_parts*bytes_in_emushort );
+
+ if( frac ) pack( (EMUSHORT *)frac, p_f, n_bits );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eir ***************/
+ /* FREE p_f ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of rtoul_frac() */
+
+
+void r_remain( mpu_real *r, mpu_real *a, mpu_real *b, int nb )
+/*
+ R = remainder after dividing A by B.
+ Sign of remainder == Sign of quotient.
+ *****************************************/
+{
+ EMUSHORT *eir = NULL,
+ *eia = NULL,
+ *eib = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, eia, eib . ********************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+ unpack( eib, (EMUSHORT *)b, n_bits );
+
+ ei_remain( eir, (EMUSHORT *)0, eia, eib, n_bits );
+
+ pack( (EMUSHORT *)r, eir, n_bits );
+
+ /* FREE eir ***************/
+ /* FREE eia ***************/
+ /* FREE eib ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_remain() */
+
+
+void r_floor( mpu_real *c, mpu_real *a, int nb )
+/*
+ Return C = largest integer not greater
+ than A (truncated toward minus infinity).
+ Возвращает C = наиболшее (ближайшее) целое
+ не большее чем A (срезает в сторону
+ минус бесконечности).
+ ********************************************/
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia . *************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+
+ ei_floor( eic, eia, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_floor() */
+
+
+void r_ceil( mpu_real *c, mpu_real *a, int nb )
+/*
+ Return C = neargest integer not smaller
+ than A (truncated toward plus infinity).
+ Возвращает C = наименьшее (ближайшее) целое
+ не меньшее чем A (срезает в сторону
+ плюс бесконечности).
+ **********************************************/
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia . *************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+
+ ei_ceil( eic, eia, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_ceil() */
+
+
+void r_round( mpu_real *c, mpu_real *a, int nb )
+/*
+ Return C = nearest integer to A, as FLOOR( A + 0.5 ).
+ *******************************************************/
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia . *************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+
+ ei_round( eic, eia, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_round() */
+
+
+void r_frexp( mpu_real *s, mpu_int *lexp, mpu_real *r, int nb_l, int nb_r )
+/*
+ Return S and LEXP such that
+ S * 2^LEXP = R and 0.5 <= S < 1.0.
+ For example, 1.1 = 0.55 * 2^1.
+ ================================================
+ Функция разбивает число R на мантиссу S и
+ експоненту LEXP таким образом, что абсолютное
+ значение S больше или равно 0.5 и меньше 1.0
+ и R == S * 2^LEXP.
+ Например, 1.1 = 0.55 * 2^1.
+ ================================================
+ NOTE:
+ sizeof( lexp ) >= _sizeof_exp( unsigned nb_r ).
+ **************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_s = NULL,
+ *p_l = NULL;
+ int n_bits, n_parts, bytes_in_emushort;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits = nb_r * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_s, p_l . ********************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_s = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !p_s )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE p_s ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+
+ ei_frexp( p_s, p_l, eir, n_parts, n_bits );
+
+ /***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF. Флаги CF, AF не изменяются.
+ ***************************************************************/
+ icvt( lexp, (mpu_int *)p_l, nb_l, n_parts*bytes_in_emushort );
+
+ pack( (EMUSHORT *)s, p_s, n_bits );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eir ***************/
+ /* FREE p_s ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_frexp() */
+
+
+void r_ldexp( mpu_real *c, mpu_real *r, mpu_int *lpwr2, int nb_r, int nb_l )
+/*
+ Return C = R * 2^PWR2.
+ =====================================================
+ Функция вычисляет значение C как
+ R умноженное на 2 в степени LPWR2.
+ =====================================================
+ NOTE:
+ sizeof( lpwr2 ) <= _sizeof_exp( unsigned nb_r ) + 1.
+ *******************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_c = NULL,
+ *p_l = NULL;
+ int n_bits, n_parts, bytes_in_emushort;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits = nb_r * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_c, p_l . ********************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_c = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !p_c )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE p_c ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+ /***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF. Флаги CF, AF не изменяются.
+ ***************************************************************/
+ icvt( (mpu_int *)p_l, lpwr2, n_parts*bytes_in_emushort, nb_l );
+
+ ei_ldexp( p_c, p_l, eir, n_parts, n_bits );
+
+ pack( (EMUSHORT *)c, p_c, n_bits );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eir ***************/
+ /* FREE p_c ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_ldexp() */
+
+
+void r_logb( mpu_int *lbase2, mpu_real *r, int nb_l, int nb_r )
+/*
+ Return Lbase2 = the base 2 signed integral
+ Exponent of R.
+ ================================================
+ Функция вычисляет значение Lbase2 как
+ знаковую интегральную экспоненту по основанию 2
+ вещественного числа R.
+ ================================================
+ NOTE:
+ sizeof( lexp ) >= _sizeof_exp( unsigned nb_r ).
+ **************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *p_l = NULL;
+ int n_bits, n_parts, bytes_in_emushort;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ bytes_in_emushort = (SIZE_OF_EMUSHORT);
+ n_parts = nb_l / bytes_in_emushort + 1;
+ n_bits = nb_r * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, p_l . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ p_l = (EMUSHORT *)__mpu_sbrk( (int)(n_parts*SIZE_OF_EMUSHORT) );
+ if( !p_l )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+
+ ei_logb( p_l, eir, n_parts, n_bits );
+
+ /***************************************************************
+ Операция преобразования (convert) данных CVT.
+ Воздействует на флаги: OF, PF, SF, ZF. Флаги CF, AF не изменяются.
+ ***************************************************************/
+ icvt( lbase2, (mpu_int *)p_l, nb_l, n_parts*bytes_in_emushort );
+
+ /* FREE p_l ***************/
+ __mpu_sbrk( -(int)(n_parts*SIZE_OF_EMUSHORT) );
+ /**************************/
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_logb() */
+
+
+void r_modf( mpu_real *fract, mpu_real *integer, mpu_real *r, int nb )
+/*
+ Returns fractional part of R (in *FRACT) (with sign of R),
+ stores integer part in *INTEGER (as real number).
+ ===============================================================
+ Функция вычисляет дробную и целую части числа R.
+ ===============================================================
+ *****************************************************************/
+{
+ EMUSHORT *eir = NULL,
+ *eif = NULL,
+ *eii = NULL,
+ *zero = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eir, eif, eii, zero . **************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eif = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eif )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eii = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eii )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eif ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eif ***************/
+ /* FREE eii ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( zero, n_bits );
+
+ unpack( eir, (EMUSHORT *)r, n_bits );
+
+ ei_copy( eif, eir, n_bits );
+ ei_abs( eif, n_bits ); /* eif = abs( eir ); */
+
+ ei_floor( eii, eif, n_bits ); /* eii = floor( eif ); */
+
+ ei_sub( eif, eif, eii, n_bits ); /* eif -= eii; */
+
+ if( ei_cmp( eir, zero, n_bits ) < 0 ) /* if( eir < 0 ) */
+ {
+ ei_neg( eii, n_bits ); /* eii = -eii; */
+ ei_neg( eif, n_bits ); /* eif = -eif; */
+ }
+
+ pack( (EMUSHORT *)fract, eif, n_bits );
+ pack( (EMUSHORT *)integer, eii, n_bits );
+
+ /* FREE eir ***************/
+ /* FREE eif ***************/
+ /* FREE eii ***************/
+ /* FREE zero **************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_modf() */
+
+
+/***************************************************************
+ REAL MATHEMATIC OPERATIONS
+ ***************************************************************/
+
+void r_sqrt( mpu_real *c, mpu_real *a, int nb )
+/*
+ Longhand SQUARE ROOT routine.
+ *******************************/
+{
+ EMUSHORT *eic = NULL,
+ *eia = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eia . *************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eia, (EMUSHORT *)a, n_bits );
+
+ ei_sqrt( eic, eia, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eic ***************/
+ /* FREE eia ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_sqrt() */
+
+
+/***************************************************************
+ BEGIN: __MPU_MATH.H
+ **/
+
+void r_sin( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_sin( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_sin() */
+
+
+void r_cos( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_cos( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_cos() */
+
+
+void r_tan( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_tan( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_tan() */
+
+
+void r_log1p( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_log1p( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_log1p() */
+
+
+void r_log( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_log( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_log() */
+
+
+void r_log10( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_log10( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_log10() */
+
+
+void r_log2( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_log2( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_log2() */
+
+
+void r_expm1( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_expm1( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_expm1() */
+
+
+void r_exp( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_exp( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_exp() */
+
+
+void r_atan2( mpu_real *c, mpu_real *y, mpu_real *x, int nb )
+/*
+ rATAN2( Y,X ) RETURN ARG(EIX+iEIY); ARG(x+iy) = arctan(y/x).
+ ****************************************************************/
+{
+ EMUSHORT *eic = NULL,
+ *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eiy, eix . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+ unpack( eiy, (EMUSHORT *)y, n_bits );
+
+ ei_atan2( eic, eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_atan2() */
+
+
+void r_sinh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_sinh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_sinh() */
+
+
+void r_cosh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_cosh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_cosh() */
+
+
+void r_tanh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_tanh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_tanh() */
+
+
+void r_asinh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_asinh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_asinh() */
+
+
+void r_acosh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_acosh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_acosh() */
+
+
+void r_atanh( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_atanh( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_atanh() */
+
+
+void r_asin( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_asin( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_asin() */
+
+
+void r_acos( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_acos( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_acos() */
+
+
+void r_atan( mpu_real *y, mpu_real *x, int nb )
+/*
+ *******************************/
+{
+ EMUSHORT *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy, eix . *************************/
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+
+ ei_atan( eiy, eix, n_bits );
+
+ pack( (EMUSHORT *)y, eiy, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_atan() */
+
+
+void r_pow( mpu_real *c, mpu_real *x, mpu_real *y, int nb )
+/*
+ rPOW( C, X, Y) RETURN C = X^Y.
+ ********************************/
+{
+ EMUSHORT *eic = NULL,
+ *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eiy, eix . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+ unpack( eiy, (EMUSHORT *)y, n_bits );
+
+ ei_pow( eic, eix, eiy, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_pow() */
+
+/**
+ END: __MPU_MATH.H
+ ***************************************************************/
+
+void r_hypot( mpu_real *c, mpu_real *x, mpu_real *y, int nb )
+/*
+ rHYPOT( C, X, Y ) RETURN C = sqrt(X*X + Y*Y).
+ ***********************************************/
+{
+ EMUSHORT *eic = NULL,
+ *eiy = NULL,
+ *eix = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic, eiy, eix . ********************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy )
+ {
+ /* fatal error */
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix )
+ {
+ /* fatal error */
+
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ unpack( eix, (EMUSHORT *)x, n_bits );
+ unpack( eiy, (EMUSHORT *)y, n_bits );
+
+ ei_mul( eix, eix, eix, n_bits );
+ ei_mul( eiy, eiy, eiy, n_bits );
+ ei_add( eic, eix, eiy, n_bits );
+ ei_sqrt( eic, eic, n_bits );
+
+ pack( (EMUSHORT *)c, eic, n_bits );
+
+ /* FREE eix ***************/
+ /* FREE eiy ***************/
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of r_hypot() */
+
+
+/***************************************************************
+ BEGIN: __MPU_IOREAL.H
+ **/
+
+/*************************************************
+ ПРИМЕРЫ числовых констант для ascii_to_real():
+ real:
+ +NaN; nan; nAn; naN; Nan; и т.д. == NaN;
+ -i; +inf; inf; == inf;
+ ind; -ind; любыми буквами; == -ind;
+ -3.14e+17; + 3.14e-17; +.e; .e; e;
+ -3.14E+17; + 3.14E-17; +.E; .E; +E;
+ .;
+ ПО ПОВОДУ inf:
+ можно писать и infinity но функция
+ rASCII_TO_REAL() будет проверять только
+ первые три буквы, => все равно что писать
+ infinity или information (NOTE: отбрасывание
+ ненужных символов будет возложено на
+ функции более высокого уровня).
+ real_part only:
+ -3.14r+17; + 3.14r-17; +.r; .r; -r;
+ -3.14R+17; + 3.14R-17; +.R; .R; R;
+ imaginary only:
+ -3.14j+17; + 3.14j-17; +.j; .j; j;
+ -3.14J+17; + 3.14J-17; +.J; .J; -J;
+
+ ВЕЩЕСТВЕННЫЕ И МНИМЫЕ БЕСКОНЕЧНОСТИ
+ И НЕЧИСЛА:
+
+ infinity, inf, NaN, nan, ind, -ind,
+ inf_e, NaN_e, -ind_e,
+ inf_E, NaN_E, -ind_E, и т.д.
+ ВСЕ СУТЬ: _LONGHAND_REAL_NUMBER
+
+ inf_r, NaN_r, -ind_r,
+ inf_R, NaN_R, -ind_R, и т.д.
+ ВСЕ СУТЬ: _REAL_PART_OF_COMPLEX
+
+ inf_j, NaN_j, -ind_j,
+ inf_J, NaN_J, -ind_J, и т.д.
+ ВСЕ СУТЬ: _IMAGINARY_OF_COMPLEX
+ *************************************************/
+
+int ascii_to_real( mpu_real *c, __mpu_char8_t *s, int nb )
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+ int ret = _ASCII_TO_REAL_ERROR;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return( ret );
+ }
+ /************************************************************/
+
+ ret = ei_ascii_to_real( eic, s, n_bits );
+
+ /* В случае ошибки не портить ПРИЕМНИК! */
+ /* Если производить упаковку без проверки на ошибку
+ [ if( ret != _ASCII_TO_REAL_ERROR ) {} ], то в
+ случае ошибки в ПРИЕМНИК будет записан NaN и RET
+ будет равно RET = -1.
+ */
+ if( ret != _ASCII_TO_REAL_ERROR )
+ {
+ pack( (EMUSHORT *)c, eic, n_bits );
+ }
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( ret );
+
+} /* End of ascii_to_real() */
+
+
+/*************************************************
+ МОЖЕТ ВЫВЕСТИ:
+ NaN; -NaN; inf; -inf; -ind;
+ if( gen_plus )
+ +NaN; +inf;
+
+ Если exp_delim == 'r' || 'R' то к обозначениям
+ NaN; -NaN; inf; -inf; -ind;
+ +NaN; +inf;
+ приписывается "_r" (например, inf_r).
+
+ Если exp_delim == 'j' || 'J' то к обозначениям
+ NaN; -NaN; inf; -inf; -ind;
+ +NaN; +inf;
+ приписывается "_j" (например, inf_j).
+
+ Если exp_delim == 'e' || 'E' || (любой другой)
+ то к обозначениям
+ NaN; -NaN; inf; -inf; -ind;
+ +NaN; +inf;
+ ничего не приписывается.
+ *************************************************/
+
+void real_to_ascii( __mpu_char8_t *s, mpu_real *c, int ndigs, int exp_delim, int exp_digs, int gen_plus, int nb )
+/* ndigs - количество выводимых разрядов мантиссы */
+/* exp_delim - символ ЭКСПОНЕНТЫ */
+/* exp_digs - количество цифр ЭКСПОНЕНТЫ */
+/* gen_plus - ПРИНУДИТЕЛЬНАЯ ЗАПИСЬ символа '+'
+ перед положительной экспонентой */
+{
+ EMUSHORT *eic = NULL;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic . ******************************/
+ eic = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic )
+ {
+ /* fatal error */
+ return;
+ }
+ /************************************************************/
+
+ unpack( eic, (EMUSHORT *)c, n_bits );
+
+ ei_real_to_ascii( s, eic, ndigs, exp_delim, exp_digs, gen_plus, n_bits );
+
+ /* FREE eic ***************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of real_to_ascii() */
+
+/**
+ END: __MPU_IOREAL.H
+ ***************************************************************/
+
+
+/***************************************************************
+ COMPLEX ARITHMETIC OPERATIONS
+ ***************************************************************/
+
+/***************************************************************
+
+ complex data struct:
+
+ =====================================================================
+ index:
+ WORDS_BIG_ENDIAN == 0
+ [nRx+nIx-1], . . . , [nIx]|[nIx-1], . . ., [0].
+ WORDS_BIG_ENDIAN == 1
+ [0], . . . , [nRx-1]|[nRx], . . ., [nRx+nIx-1].
+ |--------------. . .--------------|--------------. . .--------------|
+ | Real part | Imaginary |
+ |--------------. . .--------------|--------------. . .--------------|
+ size: nRx nIx.
+
+ =====================================================================
+
+ For alternative byte,Word ordering my by typedef the complex
+ number data struct:
+
+ typedef struct {
+ #if WORDS_BIG_ENDIAN == 1
+ // SEE: t_machine.h ->, for example, -> (i386.h).
+ mpu_real re[X];
+ #endif
+ mpu_real im[X];
+ #if WORDS_BIG_ENDIAN == 0
+ mpu_real re[X];
+ #endif
+ } complex_Xbytes;
+
+ ***************************************************************/
+
+void c_real_part( mpu_real *r, mpu_complex *c, int nb )
+{
+ mpu_real *pc;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ /****************
+ mov REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 0
+ pc += nb; /* point to real_part */
+#endif
+ r_cpy( r, pc, nb );
+
+} /* End of c_real_part() */
+
+
+void c_imaginary( mpu_real *r, mpu_complex *c, int nb )
+{
+ mpu_real *pc;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ /****************
+ mov REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ r_cpy( r, pc, nb );
+
+} /* End of c_imaginary() */
+
+
+void c_real_to_complex( mpu_complex *c, mpu_real *r, int nb )
+{
+ mpu_real *pc;
+ int i;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+ for( i = 0; i < nb*2; i++ ) *pc++ = 0;
+
+ pc = c;
+
+ /****************
+ mov REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 0
+ pc += nb; /* point to real_part */
+#endif
+ r_cpy( pc, r, nb );
+
+} /* End of c_real_to_complex() */
+
+
+void c_gen_complex( mpu_complex *c, mpu_real *r, mpu_real *j, int nb )
+{
+ mpu_real *pc;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ /****************
+ mov IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ r_cpy( pc, j, nb );
+
+ /****************
+ mov REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ r_cpy( pc, r, nb );
+
+} /* End of c_gen_complex() */
+
+
+void c_polar( mpu_complex *c, mpu_real *rho, mpu_real *theta, int nb )
+/*
+ The function returns the complex value C
+ whose magnitude is rho and whose phase angle is theta.
+ ********************************************************/
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL,
+ *eirho = NULL, *eitheta = NULL;
+ mpu_real *pc;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j, eirho, eitheta . *****/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eirho = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eirho )
+ {
+ /* fatal error */
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eitheta = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eitheta )
+ {
+ /* fatal error */
+
+ /* FREE eirho *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /**********************
+ unpack MODUL & ANGLE
+ **********************/
+ unpack( eirho, (EMUSHORT *)rho, n_bits );
+ unpack( eitheta, (EMUSHORT *)theta, n_bits );
+
+ /* Find the complex value whose magnitude is rho
+ and whose phase angle is theta. */
+ /*
+ eic_r = rho * cos( theta );
+ eic_j = rho * sin( theta );
+ */
+ ei_cos( eic_r, eitheta, n_bits );
+ ei_mul( eic_r, eirho, eic_r, n_bits );
+
+ ei_sin( eic_j, eitheta, n_bits );
+ ei_mul( eic_j, eirho, eic_j, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pc, eic_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pc, eic_r, n_bits );
+
+ /* FREE eitheta ***********/
+ /* FREE eirho *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_polar() */
+
+
+void c_conj( mpu_complex *c, mpu_complex *x, int nb )
+/*
+ The function returns the conjugate of x.
+ ******************************************/
+{
+ mpu_real *pc;
+ int i, n_bits;
+
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ /* copy the complex number */
+ pc = c;
+ for( i = 0; i < nb*2; i++ ) *pc++ = *x++;
+
+ pc = c; /* return to C */
+
+ n_bits = nb * BITS_PER_BYTE;
+
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+
+ /* Negate IMAGINARY in External format */
+ e_neg( (EMUSHORT *)pc, n_bits );
+
+} /* End of c_conj() */
+
+
+void c_abs( mpu_real *r, mpu_complex *c, int nb )
+/*
+ The function returns the magnitude of C.
+ ******************************************/
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL;
+ mpu_real *pc;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ unpack( eic_j, (EMUSHORT *)pc, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ unpack( eic_r, (EMUSHORT *)pc, n_bits );
+
+ /* find the MODUL of a complex number */
+ /*
+ MOD(a+bi) = sqrt(a*a + b*b);
+ */
+ ei_mul( eic_r, eic_r, eic_r, n_bits );
+ ei_mul( eic_j, eic_j, eic_j, n_bits );
+ ei_add( eic_r, eic_r, eic_j, n_bits );
+ ei_sqrt( eic_r, eic_r, n_bits );
+
+ pack( (EMUSHORT *)r, eic_r, n_bits );
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_abs() */
+
+
+void c_norm( mpu_real *r, mpu_complex *c, int nb )
+/*
+ The function returns the squared magnitude of C.
+ **************************************************/
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL;
+ mpu_real *pc;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ unpack( eic_j, (EMUSHORT *)pc, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ unpack( eic_r, (EMUSHORT *)pc, n_bits );
+
+ /* find the MODUL of a complex number */
+ /*
+ MOD(a+bi) = sqrt(a*a + b*b);
+ */
+ ei_mul( eic_r, eic_r, eic_r, n_bits );
+ ei_mul( eic_j, eic_j, eic_j, n_bits );
+ ei_add( eic_r, eic_r, eic_j, n_bits );
+
+ pack( (EMUSHORT *)r, eic_r, n_bits );
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_norm() */
+
+
+void c_arg( mpu_real *r, mpu_complex *c, int nb )
+/*
+ The function returns the phase angle of C.
+ ********************************************/
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL;
+ mpu_real *pc;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ unpack( eic_j, (EMUSHORT *)pc, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ unpack( eic_r, (EMUSHORT *)pc, n_bits );
+
+ /* find the ARGUMENT of a complex number */
+ /*
+ ARG(a+bi) = atan2(b/a);
+ */
+ ei_atan2( eic_r, eic_j, eic_r, n_bits );
+
+ pack( (EMUSHORT *)r, eic_r, n_bits );
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_arg() */
+
+
+int c_is_equal( mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL;
+ mpu_real *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+ return( -1 );
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* IS_EQUAL ? complex numbers */
+ /*
+ if( (a+bi) == (c+di) ) return 1;
+ else return 0;
+ */
+ if( (ei_cmp( eia_r, eib_r, n_bits ) == 0) &&
+ (ei_cmp( eia_j, eib_j, n_bits ) == 0) )
+ {
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( 1 );
+ }
+ else
+ {
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( 0 );
+ }
+
+} /* End of c_is_equal() */
+
+
+int c_is_nequal( mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL;
+ mpu_real *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+ return( -1 );
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( -1 );
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* IS_NEQUAL ? complex numbers */
+ /*
+ if( (a+bi) != (c+di) ) return 1;
+ else return 0;
+ */
+ if( (ei_cmp( eia_r, eib_r, n_bits ) != 0) ||
+ (ei_cmp( eia_j, eib_j, n_bits ) != 0) )
+ {
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( 1 );
+ }
+ else
+ {
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return( 0 );
+ }
+
+} /* End of c_is_nequal() */
+
+
+void c_cpy( mpu_complex *a, mpu_complex *b, int nb )
+{
+ int i;
+
+ for( i = 0; i < nb*2; i++ ) *a++ = *b++;
+
+} /* End of c_cpy() */
+
+
+void c_cvt( mpu_complex *a, mpu_complex *b, int nb_a, int nb_b )
+{
+ EMUSHORT *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL;
+ mpu_real *pa, *pb;
+ int n_bits_a, n_bits_b;
+ int np_a, np_b;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+
+ n_bits_a = nb_a * BITS_PER_BYTE;
+ n_bits_b = nb_b * BITS_PER_BYTE;
+
+ np_a = internal_np( n_bits_a );
+ np_b = internal_np( n_bits_b );
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np_a*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np_a*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np_b*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(2*np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np_b*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ __mpu_sbrk( -(int)(np_b*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(2*np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pb += nb_b; /* point to imaginary */
+#endif
+ unpack( eib_j, (EMUSHORT *)pb, n_bits_b );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pb -= nb_b; /* point to real_part */
+#else
+ pb += nb_b; /* point to real_part */
+#endif
+ unpack( eib_r, (EMUSHORT *)pb, n_bits_b );
+
+ /* CONVERT complex number */
+ ei_convert( (EMUSHORT *)eia_r, (EMUSHORT *)eib_r, n_bits_a, n_bits_b );
+ ei_convert( (EMUSHORT *)eia_j, (EMUSHORT *)eib_j, n_bits_a, n_bits_b );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb_a; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pa, eia_j, n_bits_a );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb_a; /* point to real_part */
+#else
+ pa += nb_a; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pa, eia_r, n_bits_a );
+
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ __mpu_sbrk( -(int)(2*np_b*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ __mpu_sbrk( -(int)(2*np_a*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_cvt() */
+
+
+void c_add( mpu_complex *c, mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL,
+ *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL;
+ mpu_real *pc, *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* ADD complex numbers */
+ /*
+ (a+bi) + (c+di) = (a + c) + (b + d)i;
+ */
+ ei_add( eic_r, eia_r, eib_r, n_bits );
+ ei_add( eic_j, eia_j, eib_j, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pc, eic_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pc, eic_r, n_bits );
+
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_add() */
+
+
+void c_sub( mpu_complex *c, mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL,
+ *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL;
+ mpu_real *pc, *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* SUB complex numbers */
+ /*
+ (a+bi) - (c+di) = (a - c) + (b - d)i;
+ */
+ ei_sub( eic_r, eia_r, eib_r, n_bits );
+ ei_sub( eic_j, eia_j, eib_j, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pc, eic_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pc, eic_r, n_bits );
+
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_sub() */
+
+
+void c_mul( mpu_complex *c, mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL,
+ *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL,
+ *eitmp = NULL;
+ mpu_real *pc, *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eitmp . ****************************/
+ eitmp = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eitmp )
+ {
+ /* fatal error */
+
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* MUL complex numbers */
+ /*
+ (a+bi) * (c+di) = (a*c - b*d) + (a*d + b*c)i;
+ */
+ ei_mul( eic_r, eia_r, eib_r, n_bits );
+ ei_mul( eitmp, eia_j, eib_j, n_bits );
+ ei_sub( eic_r, eic_r, eitmp, n_bits );
+
+ ei_mul( eic_j, eia_r, eib_j, n_bits );
+ ei_mul( eitmp, eia_j, eib_r, n_bits );
+ ei_add( eic_j, eic_j, eitmp, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pc, eic_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pc, eic_r, n_bits );
+
+ /* FREE eitmp *************/
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(7*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_mul() */
+
+
+static void __complex_divide_by_zero( void )
+{
+ /* error: Complex attempted division by zero */
+ struct __exception e;
+
+ __complex_error_no = __C_EDIVZEROBYZERO__;
+
+ e.who = _COMPLEX_;
+ e.type = __complex_error_no;
+ e.name = (__mpu_char8_t *)"c_div";
+ e.msg = __mpu_utf8mpu_error( _COMPLEX_, __complex_error_no );
+ e.msg_type = _ERROR_MSG_;
+ e.nb_a1 = 0;
+ e.nb_a2 = 0;
+ e.nb_rv = 0;
+ e.arg_1 = (unsigned char *)0;
+ e.arg_2 = (unsigned char *)0;
+ e.return_value = (unsigned char *)0;
+
+ if( __extra_warnings )
+ {
+ __mpu_warning( &e );
+ }
+
+ if( e.msg ) free( e.msg );
+
+ return;
+
+} /* End of __complex_divide_by_zero( void ) */
+
+void c_div( mpu_complex *c, mpu_complex *a, mpu_complex *b, int nb )
+{
+ EMUSHORT *eic_r = NULL, *eic_j = NULL,
+ *eia_r = NULL, *eia_j = NULL,
+ *eib_r = NULL, *eib_j = NULL,
+ *eitmp = NULL, *eiden = NULL,
+ *zero = NULL;
+ mpu_real *pc, *pa, *pb;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pa = a;
+ pb = b;
+ pc = c;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eic_r, eic_j . *********************/
+ eic_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eic_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eic_j )
+ {
+ /* fatal error */
+
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eia_r, eia_j, eib_r, eib_j . *******/
+ eia_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_r )
+ {
+ /* fatal error */
+
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eia_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia_j )
+ {
+ /* fatal error */
+
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_r )
+ {
+ /* fatal error */
+
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eib_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eib_j )
+ {
+ /* fatal error */
+
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eitmp, eiden, zero . ***************/
+ eitmp = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eitmp )
+ {
+ /* fatal error */
+
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eiden = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiden )
+ {
+ /* fatal error */
+
+ /* FREE eitmp *************/
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(7*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eiden *************/
+ /* FREE eitmp *************/
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(8*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( zero, n_bits );
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa += nb; /* point to imaginary */
+ pb += nb;
+#endif
+ unpack( eia_j, (EMUSHORT *)pa, n_bits );
+ unpack( eib_j, (EMUSHORT *)pb, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pa -= nb; /* point to real_part */
+ pb -= nb;
+#else
+ pa += nb; /* point to real_part */
+ pb += nb;
+#endif
+ unpack( eia_r, (EMUSHORT *)pa, n_bits );
+ unpack( eib_r, (EMUSHORT *)pb, n_bits );
+
+ /* DIVIDE complex numbers */
+ /*
+ hyp = c^2 + d^2;
+ (a+bi) / (c+di) = (a*c + b*d)/hyp + (c*b - d*a)i;
+ */
+ ei_mul( eiden, eib_r, eib_r, n_bits );
+ ei_mul( eitmp, eib_j, eib_j, n_bits );
+ ei_add( eiden, eiden, eitmp, n_bits ); /* den */
+
+ /*****************************************************
+ Если EIDEN == 0, результат будет неопределен (InD).
+ *****************************************************/
+ if( ei_cmp( eiden, zero, n_bits ) == 0 )
+ {
+ /*****************************************
+ Выставление InD произойдет и без этих
+ операторов, но переход сразу на packing
+ сократит время работы этой функции.
+ *****************************************/
+ ei_ind( eic_r, n_bits );
+ ei_ind( eic_j, n_bits );
+ __complex_divide_by_zero();
+ goto packing;
+
+ } /* End if( ZERO/ZERO ) */
+
+ ei_mul( eic_r, eia_r, eib_r, n_bits );
+ ei_mul( eitmp, eia_j, eib_j, n_bits );
+ ei_add( eic_r, eic_r, eitmp, n_bits ); /* (a*c + b*d) */
+ ei_div( eic_r, eic_r, eiden, n_bits );
+
+ ei_mul( eic_j, eib_r, eia_j, n_bits );
+ ei_mul( eitmp, eib_j, eia_r, n_bits );
+ ei_sub( eic_j, eic_j, eitmp, n_bits ); /* (c*b - d*a) */
+ ei_div( eic_j, eic_j, eiden, n_bits );
+
+packing:
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)pc, eic_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ pc -= nb; /* point to real_part */
+#else
+ pc += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)pc, eic_r, n_bits );
+
+ /* FREE zero **************/
+ /* FREE eiden *************/
+ /* FREE eitmp *************/
+ /* FREE eib_j *************/
+ /* FREE eib_r *************/
+ /* FREE eia_j *************/
+ /* FREE eia_r *************/
+ /* FREE eic_j *************/
+ /* FREE eic_r *************/
+ __mpu_sbrk( -(int)(9*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_div() */
+
+
+/***************************************************************
+ COMPLEX MATHEMATIC OPERATIONS
+ ***************************************************************/
+
+void c_exp( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the exponential of X.
+ ********************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir . ******************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* EXP of a complex number */
+ /*
+ real r = exp( x.real );
+
+ y.real = r * cos( x.imag );
+ y.imag = r * sin( x.imag );
+ */
+ ei_exp( eir, eix_r, n_bits );
+ ei_cos( eiy_r, eix_j, n_bits );
+ ei_mul( eiy_r, eir, eiy_r, n_bits );
+ ei_sin( eiy_j, eix_j, n_bits );
+ ei_mul( eiy_j, eir, eiy_j, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_exp() */
+
+
+void c_sin( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the imaginary sine of X.
+ ***********************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* SIN of a complex number */
+ /*
+ y.real = sin( x.real ) * cosh( x.imag );
+ y.imag = cos( x.real ) * sinh( x.imag );
+ */
+ ei_sin( eir, eix_r, n_bits );
+ ei_cosh( eij, eix_j, n_bits );
+ ei_mul( eiy_r, eir, eij, n_bits );
+ ei_cos( eir, eix_r, n_bits );
+ ei_sinh( eij, eix_j, n_bits );
+ ei_mul( eiy_j, eir, eij, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_sin() */
+
+
+void c_cos( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the cosine of X.
+ *******************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* COS of a complex number */
+ /*
+ y.real = cos( x.real ) * cosh( x.imag );
+ y.imag = -sin( x.real ) * sinh( x.imag );
+ */
+ ei_cos( eir, eix_r, n_bits );
+ ei_cosh( eij, eix_j, n_bits );
+ ei_mul( eiy_r, eir, eij, n_bits );
+ ei_sin( eir, eix_r, n_bits );
+ ei_neg( eir, n_bits );
+ ei_sinh( eij, eix_j, n_bits );
+ ei_mul( eiy_j, eir, eij, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_cos() */
+
+
+void c_sinh( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the hyperbolic sine of X.
+ ************************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* SINH of a complex number */
+ /*
+ y.real = cos( x.imag ) * sinh( x.real );
+ y.imag = sin( x.imag ) * cosh( x.real );
+ */
+ ei_cos( eij, eix_j, n_bits );
+ ei_sinh( eir, eix_r, n_bits );
+ ei_mul( eiy_r, eij, eir, n_bits );
+ ei_sin( eij, eix_j, n_bits );
+ ei_cosh( eir, eix_r, n_bits );
+ ei_mul( eiy_j, eij, eir, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_sinh() */
+
+
+void c_cosh( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the hyperbolic cosine of X.
+ **************************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* COSH of a complex number */
+ /*
+ y.real = cos( x.imag ) * cosh( x.real );
+ y.imag = sin( x.imag ) * sinh( x.real );
+ */
+ ei_cos( eij, eix_j, n_bits );
+ ei_cosh( eir, eix_r, n_bits );
+ ei_mul( eiy_r, eij, eir, n_bits );
+ ei_sin( eij, eix_j, n_bits );
+ ei_sinh( eir, eix_r, n_bits );
+ ei_mul( eiy_j, eij, eir, n_bits );
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_cosh() */
+
+
+static void __complex_LOG_of_zero( void )
+{
+ /* error: Complex attempted LOG of zero magnitude number */
+ struct __exception e;
+
+ __complex_error_no = __C_ELOGOFZERO__;
+
+ e.who = _COMPLEX_;
+ e.type = __complex_error_no;
+ e.name = (__mpu_char8_t *)"c_log";
+ e.msg = __mpu_utf8mpu_error( _COMPLEX_, __complex_error_no );
+ e.msg_type = _ERROR_MSG_;
+ e.nb_a1 = 0;
+ e.nb_a2 = 0;
+ e.nb_rv = 0;
+ e.arg_1 = (unsigned char *)0;
+ e.arg_2 = (unsigned char *)0;
+ e.return_value = (unsigned char *)0;
+
+ if( __extra_warnings )
+ {
+ __mpu_warning( &e );
+ }
+
+ if( e.msg ) free( e.msg );
+
+ return;
+
+} /* End of __complex_LOG_of_zero( void ) */
+
+void c_log( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the logarithm of X.
+ The branch cuts are along the negative real axis.
+ ***************************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL,
+ *zero = NULL,
+ *eih = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for zero, eih . ************************/
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eih = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eih )
+ {
+ /* fatal error */
+
+ /* FREE zero **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(7*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( zero, n_bits );
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* LOG of a complex number */
+ /*
+ real h = hypot( x.real, x.imag );
+
+ if( h <= 0.0 )
+ x.error("attempted LOG of zero magnitude number.");
+
+ y.real = log( h );
+ y.imag = atan2( x.imag, x.real );
+ */
+ ei_mul( eir, eix_r, eix_r, n_bits );
+ ei_mul( eij, eix_j, eix_j, n_bits );
+ ei_add( eih, eir, eij, n_bits );
+ ei_sqrt( eih, eih, n_bits ); /* eih = hypot( eix_r, eix_j ); */
+
+ if( ei_cmp( eih, zero, n_bits ) <= 0 )
+ {
+ /*****************************************
+ Выставление -InF произойдет и без этих
+ операторов, но переход сразу на packing
+ сократит время работы этой функции.
+ *****************************************/
+ ei_infin( eiy_r, (unsigned)1, n_bits );
+ _gen_zero( eiy_j, n_bits );
+ __complex_LOG_of_zero();
+ goto packing;
+ }
+
+ ei_log( eiy_r, eih, n_bits );
+ ei_atan2( eiy_j, eix_j, eix_r, n_bits );
+
+packing:
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eih ***************/
+ /* FREE zero **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(8*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_log() */
+
+
+static void __complex_POW_of_zero( void )
+{
+ /* error: Complex attempted POW of zero magnitude number */
+ struct __exception e;
+
+ __complex_error_no = __C_EPOWOFZERO__;
+
+ e.who = _COMPLEX_;
+ e.type = __complex_error_no;
+ e.name = (__mpu_char8_t *)"c_pow";
+ e.msg = __mpu_utf8mpu_error( _COMPLEX_, __complex_error_no );
+ e.msg_type = _ERROR_MSG_;
+ e.nb_a1 = 0;
+ e.nb_a2 = 0;
+ e.nb_rv = 0;
+ e.arg_1 = (unsigned char *)0;
+ e.arg_2 = (unsigned char *)0;
+ e.return_value = (unsigned char *)0;
+
+ if( __extra_warnings )
+ {
+ __mpu_warning( &e );
+ }
+
+ if( e.msg ) free( e.msg );
+
+ return;
+
+} /* End of __complex_POW_of_zero( void ) */
+
+void c_pow( mpu_complex *y, mpu_complex *x, mpu_complex *p, int nb )
+/*
+ The functions return the Y = X^P.
+ The branch cut for x is along the negative real axis.
+ *******************************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eip_r = NULL, *eip_j = NULL,
+ *eir = NULL, *eij = NULL,
+ *eilr = NULL, *eilj = NULL,
+ *zero = NULL,
+ *eih = NULL, *eia = NULL;
+ mpu_real *py, *px, *pp;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ pp = p;
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eip_r, eip_j . *********************/
+ eip_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eip_r )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eip_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eip_j )
+ {
+ /* fatal error */
+
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(7*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eilr, eilj . ***********************/
+ eilr = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eilr )
+ {
+ /* fatal error */
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(8*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eilj = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eilj )
+ {
+ /* fatal error */
+
+ /* FREE eilr **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(9*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for zero, eih, eia . *******************/
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eilj **************/
+ /* FREE eilr **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(10*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eih = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eih )
+ {
+ /* fatal error */
+
+ /* FREE zero **************/
+ /* FREE eilj **************/
+ /* FREE eilr **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(11*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eia = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eia )
+ {
+ /* fatal error */
+
+ /* FREE eih ***************/
+ /* FREE zero **************/
+ /* FREE eilj **************/
+ /* FREE eilr **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(12*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( zero, n_bits );
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+ pp += nb;
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+ unpack( eip_j, (EMUSHORT *)pp, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+ pp -= nb;
+#else
+ px += nb; /* point to real_part */
+ pp += nb;
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+ unpack( eip_r, (EMUSHORT *)pp, n_bits );
+
+ /* POW of a complex number */
+ /*
+ real h = hypot( x.real, x.imag );
+
+ if( h <= 0.0 )
+ x.error("attempted POWER of zero magnitude number.");
+
+ real a = atan2( x.imag, x.real );
+ real lr = pow( h, p.real );
+ real lj = p.real * a;
+
+ if( p.imag != 0.0 )
+ {
+ lr /= exp( p.imag * a );
+ lj += p.imag * log( h );
+ }
+
+ y.real = lr * cos( lj );
+ y.imag = lr * sin( lj );
+ */
+ ei_mul( eir, eix_r, eix_r, n_bits );
+ ei_mul( eij, eix_j, eix_j, n_bits );
+ ei_add( eih, eir, eij, n_bits );
+ ei_sqrt( eih, eih, n_bits ); /* eih = hypot( eix_r, eix_j ); */
+
+ if( ei_cmp( eih, zero, n_bits ) <= 0 )
+ {
+ /*********************************************************
+ В принципе выражение 0^0, как и выражение 0/0, неопределено.
+ Но функции POW, в этом случае, возвращают 1.0 и мы не будем
+ здесь принудительно выставлять значения
+ eiy_r = 0.0,
+ eiy_j = 0.0
+ и переходить на упаковку, т.к. можем пропустить
+ выражение 0^0.
+ ==============
+ *********************************************************/
+ /* _gen_zero( eiy_j, n_bits ); */
+ /* _gen_zero( eiy_j, n_bits ); */
+ __complex_POW_of_zero();
+ /* goto packing; */
+ /*********************************************************
+ Здесь POW( 0.0r0+0.0j0, 0.0r0+0.0j0 ) == 1.0r0+0.0j0;
+ *********************************************************/
+ }
+
+ ei_atan2( eia, eix_j, eix_r, n_bits );
+ ei_pow( eilr, eih, eip_r, n_bits );
+ ei_mul( eilj, eip_r, eia, n_bits );
+
+ if( ei_cmp( eip_j, zero, n_bits ) != 0 )
+ {
+ ei_mul( eir, eip_j, eia, n_bits );
+ ei_exp( eir, eir, n_bits );
+ ei_div( eilr, eilr, eir, n_bits ); /* lr /= exp( p.imag * a ); */
+
+ ei_log( eij, eih, n_bits );
+ ei_mul( eij, eip_j, eij, n_bits );
+ ei_add( eilj, eilj, eij, n_bits ); /* lj += p.imag * log( h ); */
+ }
+
+ ei_cos( eir, eilj, n_bits );
+ ei_mul( eiy_r, eilr, eir, n_bits ); /* y.real = lr * cos( lj ); */
+
+ ei_sin( eij, eilj, n_bits );
+ ei_mul( eiy_j, eilr, eij, n_bits ); /* y.imag = lr * sin( lj ); */
+
+/* packing: */
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eia ***************/
+ /* FREE eih ***************/
+ /* FREE zero **************/
+ /* FREE eilj **************/
+ /* FREE eilr **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eip_j *************/
+ /* FREE eip_r *************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(13*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_pow() */
+
+
+void c_sqrt( mpu_complex *y, mpu_complex *x, int nb )
+/*
+ The function returns the square root of X, with
+ phase angle in the half-open interval (-pi/2, pi/2].
+ The branch cuts are along the negative real axis.
+ ******************************************************/
+{
+ EMUSHORT *eiy_r = NULL, *eiy_j = NULL,
+ *eix_r = NULL, *eix_j = NULL,
+ *eir = NULL, *eij = NULL,
+ *zero = NULL, *half = NULL,
+ *eih = NULL;
+ mpu_real *py, *px;
+ int n_bits;
+ int np;
+
+ errno = 0;
+ __real_error_no = 0;
+
+ __CLEAR_RFLAGS;
+
+ px = x;
+ py = y;
+
+ n_bits = nb * BITS_PER_BYTE;
+
+ np = internal_np( n_bits );
+
+ /*** Allocate memory for eiy_r, eiy_j, eix_r, eix_j . *******/
+ eiy_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_r )
+ {
+ /* fatal error */
+ return;
+ }
+
+ eiy_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eiy_j )
+ {
+ /* fatal error */
+
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_r = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_r )
+ {
+ /* fatal error */
+
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(2*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eix_j = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eix_j )
+ {
+ /* fatal error */
+
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(3*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for eir, eij . *************************/
+ eir = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eir )
+ {
+ /* fatal error */
+
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(4*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eij = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eij )
+ {
+ /* fatal error */
+
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(5*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ /*** Allocate memory for zero, half, eih . ******************/
+ zero = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !zero )
+ {
+ /* fatal error */
+
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(6*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ half = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !half )
+ {
+ /* fatal error */
+
+ /* FREE zero **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(7*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+
+ eih = (EMUSHORT *)__mpu_sbrk( (int)(np*SIZE_OF_EMUSHORT) );
+ if( !eih )
+ {
+ /* fatal error */
+
+ /* FREE half **************/
+ /* FREE zero **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(8*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+ return;
+ }
+ /************************************************************/
+
+ _gen_zero( zero, n_bits );
+ _gen_half( half, n_bits );
+
+ /******************
+ unpack IMAGINARY
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px += nb; /* point to imaginary */
+#endif
+ unpack( eix_j, (EMUSHORT *)px, n_bits );
+
+ /******************
+ unpack REAL_PART
+ ******************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ px -= nb; /* point to real_part */
+#else
+ px += nb; /* point to real_part */
+#endif
+ unpack( eix_r, (EMUSHORT *)px, n_bits );
+
+ /* SQRT of a complex number */
+ /*
+ if( x.real == 0.0 && x.imag == 0.0 )
+ {
+ y.real = 0.0;
+ y.imag = 0.0;
+ }
+ else
+ {
+ real s = sqrt( (abs( x.real ) + hypot( x.real, x.imag )) * 0.5 );
+ real d = ( x.imag / s ) * 0.5;
+
+ if( x.real > 0.0 )
+ {
+ y.real = s;
+ y.imag = d;
+ }
+ else if( x.imag >= 0.0 )
+ {
+ y.real = d;
+ y.imag = s;
+ }
+ else
+ {
+ y.real = -d;
+ y.imag = -s;
+ }
+ }
+ */
+
+ if( (ei_cmp( eix_r, zero, n_bits ) == 0) &&
+ (ei_cmp( eix_j, zero, n_bits ) == 0) )
+ {
+ _gen_zero( eiy_r, n_bits );
+ _gen_zero( eiy_j, n_bits );
+ }
+ else
+ {
+ ei_mul( eir, eix_r, eix_r, n_bits );
+ ei_mul( eij, eix_j, eix_j, n_bits );
+ ei_add( eih, eir, eij, n_bits );
+ ei_sqrt( eih, eih, n_bits ); /* eih = hypot( eix_r, eix_j ); */
+
+ ei_copy( eir, eix_r, n_bits );
+ ei_abs( eir, n_bits ); /* eir = abs( eix_r ); */
+
+ ei_add( eir, eir, eih, n_bits );
+ ei_mul( eir, eir, half, n_bits );
+ ei_sqrt( eir, eir, n_bits ); /* s := eir; */
+
+ ei_div( eij, eix_j, eir, n_bits );
+ ei_mul( eij, eij, half, n_bits ); /* d := eij; */
+
+ if( ei_cmp( eix_r, zero, n_bits ) > 0 )
+ {
+ ei_copy( eiy_r, eir, n_bits ); /* y.real = s; */
+ ei_copy( eiy_j, eij, n_bits ); /* y.imag = d; */
+ }
+ else if( ei_cmp( eix_j, zero, n_bits ) >= 0 )
+ {
+ ei_copy( eiy_r, eij, n_bits ); /* y.real = d; */
+ ei_copy( eiy_j, eir, n_bits ); /* y.imag = s; */
+ }
+ else
+ {
+ ei_neg( eir, n_bits );
+ ei_neg( eij, n_bits );
+
+ ei_copy( eiy_r, eij, n_bits ); /* y.real = -d; */
+ ei_copy( eiy_j, eir, n_bits ); /* y.imag = -s; */
+ }
+
+ } /* End if( X != 0.0r0+0.0j0 ) */
+
+ /****************
+ pack IMAGINARY
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py += nb; /* point to imaginary */
+#endif
+ pack( (EMUSHORT *)py, eiy_j, n_bits );
+
+ /****************
+ pack REAL_PART
+ ****************/
+#if MPU_WORD_ORDER_BIG_ENDIAN == 1
+ py -= nb; /* point to real_part */
+#else
+ py += nb; /* point to real_part */
+#endif
+ pack( (EMUSHORT *)py, eiy_r, n_bits );
+
+ /* FREE eih ***************/
+ /* FREE half **************/
+ /* FREE zero **************/
+ /* FREE eij ***************/
+ /* FREE eir ***************/
+ /* FREE eix_j *************/
+ /* FREE eix_r *************/
+ /* FREE eiy_j *************/
+ /* FREE eiy_r *************/
+ __mpu_sbrk( -(int)(9*np*SIZE_OF_EMUSHORT) );
+ /**************************/
+
+} /* End of c_sqrt() */
+