Длинная арифметика на Си

#define USHRT_MAX     0xffff        /* maximum unsigned short value */
#define UINT_MAX      0xffffffff    /* maximum unsigned int value */
#define ULONG_MAX     0xffffffffUL  /* maximum unsigned long value */

#include <stdio.h>
 
#define SIZE 3
 
void _print_real (unsigned short * num, size_t size) 
{
    while (size--)
        printf("%0.4X ", num[size]);
    printf("\n");
}
 
int main(void)
{
    unsigned short real[SIZE] = { 0xFFFF, 0x0FFF, 0x1 };
    _print_real(real, SIZE);
}

#define REAL_BASE      0x10000  /* база или "система счисления" длинного числа */
#define REAL_MAX_ORDER 4        /* максимальное количество разрядов в одном длинном числе */

#ifndef USHORT
typedef unsigned short USHORT;
#endif /* !defined USHORT */
#ifndef ULONG 
typedef unsigned long ULONG;
#endif /* !defined ULONG */

typedef unsigned short _real_int;               /* один разряд длинного числа */
typedef _real_int      REALINT[REAL_MAX_ORDER]; /* одно длинное число */
typedef _real_int *    PREALINT;                /* указатель на длинное число */
typedef _real_int **   LPREALINT;               /* двойной указатель на длинное число */

#include <stdio.h>
 
#define REAL_BASE      0x10000  /* база или "система счисления" длинного числа */
#define REAL_MAX_ORDER 4        /* максимальное количество разрядов в одном длинном числе */
 
#ifndef USHORT
typedef unsigned short USHORT;
#endif /* !defined USHORT */
#ifndef ULONG 
typedef unsigned long ULONG;
#endif /* !defined ULONG */
 
typedef unsigned short _real_int;               /* один разряд длинного числа */
typedef _real_int      REALINT[REAL_MAX_ORDER]; /* одно длинное число */
typedef _real_int *    PREALINT;                /* указатель на длинное число */
typedef _real_int **   LPREALINT;               /* двойной указатель на длинное число */
 
/* ФУНКЦИЯ ВЫВОДА */
void _print_real (PREALINT num, size_t size) 
{
    while (size--)
        printf("%0.4X ", num[size]);
    printf("\n");
}
 
int main(void)
{
    REALINT real = { 0xAABB, 0xCCDD, 0xEEFF, 0x1111 };
    _print_real(real, REAL_MAX_ORDER);
}

void add (PREALINT u, PREALINT v, PREALINT w)

/* сложение неотрицательных чисел */
void add (PREALINT u, PREALINT v, PREALINT w)
{
    _real_int j = 0, k = 0;
 
    for (j = 0; j < REAL_MAX_ORDER; ++j)
    {
        w[j] = u[j] + v[j] + k;
        k = (u[j] + v[j] + k)/REAL_BASE;
    }
 
    if (k != 0)
        w[j] = k;
}

#include <stdlib.h>
#include <stdio.h>
#include "real.h"
 
void _print_real (PREALINT num, size_t size); /* функция вывода */
 
/* сложение неотрицательных чисел */
void add (PREALINT u, PREALINT v, PREALINT w)
{
    _real_int j = 0, k = 0;
 
    for (j = 0; j < REAL_MAX_ORDER; ++j)
    {
        w[j] = u[j] + v[j] + k;
        k = (u[j] + v[j] + k)/REAL_BASE;
    }
 
    if (k != 0)
        w[j] = k;
}
 
int main(void)
{
    REALINT real_a = { 0x1111, 0xEEFF }; /* первый операнд */
    REALINT real_b = { 0x234F, 0xFFFF }; /* второй операнд */
 
    REALINT real_c = { 0 }; /* результат */
    
    _print_real(real_a, REAL_MAX_ORDER); 
    _print_real(real_b, REAL_MAX_ORDER);
 
    add (real_a, real_b, real_c); /* операция сложения */
 
    _print_real(real_c, REAL_MAX_ORDER);
}
 
void _print_real (PREALINT num, size_t size) 
{
    while (size--)
        printf("%0.4X ", num[size]);
    printf("\n");
}

void add (PREALINT u, size_t len_u, PREALINT v, size_t len_v, PREALINT w, size_t len_w);

/* сложение неотрицательных чисел */
void add (PREALINT u, size_t len_u, PREALINT v, size_t len_v, PREALINT w, size_t len_w)
{
    _real_int j = 0, k = 0;
 
/* 1 */
    if (len_u < len_v)
    {
        add (v, len_v, u, len_u, w, len_w);
        return;
    }
/* ! */
 
/* 2 */
#ifdef _DEBUG
    assert(len_w >= len_u); /* длина результирующего числа недостаточна */
#endif /* defined _DEBUG */
/* ! */
 
/* 3 */
    for (j = 0; j < len_v; ++j)
    {
        w[j] = u[j] + v[j] + k;
        k = (USHORT)((u[j] + v[j] + k) / REAL_BASE);
    }
/* ! */
 
/* 4 */
    for ( ; j < len_u; ++j)
    {
        w[j] = u[j] + k;
        k = (USHORT)((u[j] + k) / REAL_BASE);
    }
/* ! */
 
/* 5 */
    if (k != 0)
        w[j] = k;
/* ! */
}

    REALINT real_a = { 0xFFFF }; /* первый операнд */
    REALINT real_b = { 1, 0xFFFF, 0xFFFF }; /* второй операнд */
 
    REALINT real_c = { 0 }; /* результат */
    
    add (real_a, 2, real_b, 3, real_c, 4); /* операция сложения */

la_int_t la1, la2, la3;
 
la_add( &la1, &la2, &la3 );

#define BIGINT_BASE       0x10000UL
#define BIGINT_MAX_ORDERS 4U
#define BIGINT_MAX_SIZE   (BIGINT_MAX_ORDERS + 1)

typedef unsigned short bigint_t;
 
typedef bigint_t    BIGINT[BIGINT_MAX_SIZE];
typedef bigint_t *  PBIGINT;
typedef bigint_t ** LPBIGINTT;

/* return length of BIGINT */
#define BIGINT_LENGTH(bigint) \
    ((USHORT)*(bigint))
 
/* return the most significant digit of BIGINT */
#define BIGINT_MSDPTR(bigint) \
    ((bigint) + (BIGINT_LENGTH(bigint)))
 
/* return the least significant digit of BIGINT */
#define BIGINT_LSDPTR(bigint) \
    ((bigint) + (1))

#include <stdio.h>
#include "bigint.h"
 
void _bigint_print (PBIGINT n)
{
    PBIGINT msdptr, lsdptr;
 
    for (msdptr = BIGINT_MSDPTR(n), lsdptr = BIGINT_LSDPTR(n); msdptr >= lsdptr; msdptr--)
        printf("%04X ", *msdptr);
    printf("\n");
}
 
int main(void)
{
    BIGINT a = { BIGINT_MAX_ORDERS, 0xFFFF }; 
    BIGINT b = { BIGINT_MAX_ORDERS, 0x1111, 0x2222, 0x3333, 0x4444 }; 
    BIGINT c = { BIGINT_MAX_ORDERS, 0 };
 
    _bigint_print (a);
    _bigint_print (b);
    _bigint_print (c);
}