3
\$\begingroup\$

Something was breaking in this question. A code-formatted block follows a numbered list, and the code isn't <pre>-formatted. I'm guessing that it has to do with the many < and > symbols involved. Workaround is to put a dummy tag between the list and code block.

example text:

A ***CORDIC division*** is implemented using ***CORDIC multiplication***, rearranging as follows:

    c = a/b
    a - c*b = 0

For the multiplication `z = x*y`:

> <sup>[[source]][2]</sup> ***z*** is composed of shifted versions of ***y***. The unknown value for ***z***, may be found by driving ***x*** to zero 1 bit at a time. If the *i<sup><sup> </sup>th</sup>* bit of ***x*** is nonzero, ***y**<sup><sup> </sup>i</sup>* is right shifted by *i* bits and added to the current value of ***z***. The *i<sup><sup> </sup>th</sup>* bit is then removed from ***x*** by subtracting *2<sup>-i</sup>* from ***x***. If ***x*** is negative, the *i<sup><sup> </sup>th</sup>* bit in the twos complement format would be removed by adding *2<sup>-i</sup>*. In either case, when ***x*** has been driven to zero all bits have been examined and ***z*** contains the signed product of ***x*** and ***y*** correct to *B* bits.

>This algorithm is similar to the standard shift and add multiplication algorithm except for two important features:

> 1. Arithmetic right shifts  are used instead of left shifts, allowing signed numbers to be used.
> 2. Computing the product to *B* bits with the CORDIC algorithm is equivalent to rounding the result of the standard algorithm to the most significant *B* bits.


>     divide_4q(x,y){
>        for (i=1; i=<B; i++){
>           if (x > 0)
>             if (y > 0)
>                x = x - y*2^(-i);
>                z = z + 2^(-i);
>             else
>                x = x + y*2^(-i);
>                z = z - 2^(-i);
>           else          
>              if (y > 0)
>                 x = x + y*2^(-i);
>                 z = z - 2^(-i);
>              else
>                 x = x - y*2^(-i);
>                 z = z + 2^(-i);
>        }
>        return(z)
>     }

Broken result:

A CORDIC division is implemented using CORDIC multiplication, rearranging as follows:

c = a/b
a - c*b = 0

For the multiplication z = x*y:

[source] z is composed of shifted versions of y. The unknown value for z, may be found by driving x to zero 1 bit at a time. If the i th bit of x is nonzero, y i is right shifted by i bits and added to the current value of z. The i th bit is then removed from x by subtracting 2-i from x. If x is negative, the i th bit in the twos complement format would be removed by adding 2-i. In either case, when x has been driven to zero all bits have been examined and z contains the signed product of x and y correct to B bits.

This algorithm is similar to the standard shift and add multiplication algorithm except for two important features:

  1. Arithmetic right shifts are used instead of left shifts, allowing signed numbers to be used.
  2. Computing the product to B bits with the CORDIC algorithm is equivalent to rounding the result of the standard algorithm to the most significant B bits.

    divide_4q(x,y){ for (i=1; i= 0) if (y > 0) x = x - y*2^(-i); z = z + 2^(-i); else x = x + y*2^(-i); z = z - 2^(-i); else
    if (y > 0) x = x + y*2^(-i); z = z - 2^(-i); else x = x - y*2^(-i); z = z + 2^(-i); } return(z) }

Fixed result:

(with <tyblus-unbreak-tag> between numbered list and code block)

A CORDIC division is implemented using CORDIC multiplication, rearranging as follows:

c = a/b
a - c*b = 0

For the multiplication z = x*y:

[source] z is composed of shifted versions of y. The unknown value for z, may be found by driving x to zero 1 bit at a time. If the i th bit of x is nonzero, y i is right shifted by i bits and added to the current value of z. The i th bit is then removed from x by subtracting 2-i from x. If x is negative, the i th bit in the twos complement format would be removed by adding 2-i. In either case, when x has been driven to zero all bits have been examined and z contains the signed product of x and y correct to B bits.

This algorithm is similar to the standard shift and add multiplication algorithm except for two important features:

  1. Arithmetic right shifts are used instead of left shifts, allowing signed numbers to be used.
  2. Computing the product to B bits with the CORDIC algorithm is equivalent to rounding the result of the standard algorithm to the most significant B bits.

divide_4q(x,y){
   for (i=1; i=<B; i++){
      if (x > 0)
        if (y > 0)
           x = x - y*2^(-i);
           z = z + 2^(-i);
        else
           x = x + y*2^(-i);
           z = z - 2^(-i);
      else          
         if (y > 0)
            x = x + y*2^(-i);
            z = z - 2^(-i);
         else
            x = x - y*2^(-i);
            z = z + 2^(-i);
   }
   return(z)
}
\$\endgroup\$
2
\$\begingroup\$

Please see

https://electronics.stackexchange.com/editing-help

  1. You must indent code 8 spaces if you want it to be code formatted as part of the list.

  2. If you need code formatting immediately following a list (but not as a part of the list) then you need to either insert a paragraph between or a no-op HTML tag like a HTML comment

\$\endgroup\$

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .