Изчислете експонентите само чрез събиране

За малки цели числа, защо не?

Първо, приложете умножение, като използвате многократно добавяне. След това имплементирайте pow(), като използвате многократно умножение. Ще бъде бавно, но ще работи добре.

Съществува по-бърз алгоритъм за степенуване, наречен Постепенно степенуване. Въпреки това, като се има предвид, че нямате бързо умножение, не съм сигурен, че си заслужава - може да искате първо да работите върху прилагането на алгоритъм за бързо умножение.

В съответствие с отговора на dmazzoni в синтаксис в стил c:

int mulitply(int x, int y)
{
    int product;

    for (int i = 0; i<y; i++)
       product += x;

    return product;
}

int power(int x, int exponent)
{
    int result = 1;

    for (int i = 0; i < exponent; i++)
        result = multiply(result, x);

    return result;
}

Подобно на решението на Aequitarum, но използва многократно повдигане на квадрат за степени и многократно удвояване за умножения. Трябва да е по-бързо за големи x,y:

int multiply(int x, int y) {
  int product = 0;
  int bitmask = 1;

  while (y >= bitmask) {
    if (y & bitmask) product += x;
    x += x;
    bitmask += bitmask;
  }
  return product;
}

int power(int x, int exponent)
{
  int result = 1;
  int bitmask = 1;

  while (exponent >= bitmask) {
    if (exponent & bitmask) result = multiply(result, x);
    x = multiply(x, x);
    bitmask += bitmask;
  }
  return result;
}

Много е реалистично. Не толкова много години назад процесорите нямаха ALU, което можеше да извършва каквито и да е разширени операции като умножение и деление.

Умножението обикновено се извършва чрез преместване и събиране. Ето малко псевдосглобяване:

; multiply registers a and b

; use c as high b
mov c,#0
; use d as low result
mov d,#0
; use e as high result
mov e,#0
.nextbit:
  ; shift low bit out of a
  shr a
  ; skip if zero
  bcc .noadd
    ; add b to result
    add d,b
    adc e,c
  .noadd:
  ; double b
  shl b
  rcl c
  ; test a
  cmp a,#0
bne .nextbit

(Имайте предвид, че резултатът от умножаването на двубайтови стойности е двубайтова стойност.)

След като имате умножение, можете просто да извършите цикъл, за да изчислите мощността.

използвани инструкции:

mov x,y = move y into x
shr x = shift right one bit
shl x = shift left one bit
rcl x = rotate left one bit with carry inserted
add x,y = add y to x
adc x,y = add y to x with carry
cmp x,y = compare x to y
bcc = branch on carry clear
bne = branch on not equal
#0 = literal number zero (as opposed to 0, which would be the address zero)

Може да намерите статията в Уикипедия за Умножение ALU за подходяща. Със събиране и побитови операции (и и или) можете да реализирате умножение в една стъпка на бит, вместо да се налага да добавяте толкова пъти, колкото е големината на по-малкия оператор.

степен n на степен k:

exponent(n,k) {
   for(x=1..n)
      x = x + exponent(x,k-1)
}