/*************************************************************** __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 #endif #include /* errno(3) */ #include /* strcpy(3) */ #include /* bzero(3) */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /*************************************************************** 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;] Воздействуют на флаги: 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: 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: 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: 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: 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: 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: 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: 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 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 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 []. Не изменяет значения операндов. Выставляет флаги: 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 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 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() */