;this macro convert text to float. "5.345" do dd 5.345
macro fltDat str* {
  local buffer, next
  define buffer f
  rept 8 i:1 \{
        rept 1 c: str shr ((8-i)*8) and 0FFh - 48 \\{
          match f, buffer \\\{
             define next 0
             match -=48, c \\\\{ define next 1 \\\\}
             match -=2, c \\\\{ define buffer .\\\#f
                                define next 1 \\\\}
             match -=3, c \\\\{ define buffer -f
                                define next 1 \\\\}
             match =0, next \\\\{ define buffer c\\\#f \\\\}
          \\\} \\} \}
  dd buffer
}                     
    

;is shr equivalent asm shr ? 
str shr ((8-i)*8) and 0FFh - 48    

;txt db "5.345",0
     xor ecx,ecx
l1:  mov al,[txt+ecx]
     shr  al,(8-ecx)*8
     and al,0ffh
     sub al,48
   
     inc  ecx
     cmp ecx,8
     jb   l1

    

First question how write this to asm ?

        txt db '55445',0
macro mdig t {
     mov ebx,1
     xor edx,edx
     xor eax,eax
l1:  mov al,[t-1+ebx]
     test al,al
     jz   ext     
     mov cl,8
     sub cl,bl
     shl cl,3
     shr  ax,cl ;(8-ecx)*8
     and al,0ffh
     sub al,48
     add edx,eax
     inc  ebx
     cmp ebx,8
     jb   l1
ext:
      } 
mdig txt ;edx=334h wrong. Right edx=D895h
    

mov al, [t-1+ebx]    

     mov cl,8
     sub cl,bl
     shl cl,3
     shr  ax,cl ;(8-ecx)*8
     and al,0ffh    

virtual at 0
     ark::
         ark_txt1 db '55445',0 ;i think i can do 64 bit int values !
;ark_txt1 db '44441554451230',0 ;yes i test and get rax=286B5B10FB1Eh
     ark_size:
end virtual
;in code
Start:  
kuuu = 0
repeat ark_size
  load a byte from ark:%-1
  if a = 0
   break
  end if
  kuuu = kuuu*10+a-48
end repeat       
mov eax,kuuu  ;eax=D895h (decimal 55445)
    

double sin_e2(double x) {
  double result = 0;
  int sign = 1;
  double xx = x * x;
  double pw = x;
  double fti = 1.0;
  for(int i = 1; i < 25; i += 2) {
    fti /= i;
    result += sign * pw * fti;
    fti /= ( i + 1 );
    sign = -sign;
    pw  *= xx;
  }
  return result;
}
    

rept will do preprocessor arithmetic. Good luck.

But not supported 1.0/num.

rept 1 x:1/2 { display x+'0' }    

rept 1 x:1/2 { display x+'0' }

rept 1 x:1/2 { mov eax, x#f }
;get mov eax,0
    

You might want to consider fixed point arithmetic using integers.

fldpi
fild dword [const360]
fidiv dword [angl]
fidiv dword [const180]
fmulp st0, st1

...

const360 dd 2
const180 dd 1
angl dd 5    

mov     eax,179.0
call    mysin     ;all ok, but failed on 180.0 get 6.01 must 0

mysin:xorps xmm3,xmm3
 cmp eax,180.0
 jz .2
 cmp eax,0
 jz .2
      movd  xmm1,eax   ;x angle
      mov   eax,1.0
      movd  xmm4,eax   ;i
      movd  xmm5,eax
      mov   eax,180.0
      movd  xmm0,eax
      divss xmm1,xmm0    ;failed if xmm1=0 or 180
      mulss xmm1,[.pi]   ;x/180*pi convert to degree 
      movss xmm0,xmm1    ;q
      mulss xmm1,xmm1    ;x*x
      
      mov   ecx,5*2
.1:   addss xmm3,xmm0       ;s+q
      mulss xmm0,[.min]     ;q = q* (-1) * (x*x) / ((2*i+1) * (2*i))
      mulss xmm0,xmm1
      movss xmm6,xmm4
      addss xmm6,xmm6
      movss xmm7,xmm6
      addss xmm6,xmm5
      mulss xmm6,xmm7
      divss xmm0,xmm6    
      addss xmm4,xmm5    ;i+1
      dec   ecx
      jnz   .1
                                    ;xmm3 out sin(x)
.2:   ret
      .pi  dd 3.141592
      .min dd -1.0 
    

The FPU has fsin.

Ok. How rewrite mysin to int for regs eax\edx ?
EAX=4 EDX=5455 this equivalent float 4.5455

You might want to consider fixed point arithmetic using integers.

#define cordic_1K 0x26DD3B6A    // 1/k = 0.6072529350088812561694
#define half_pi 0x6487ED51      // pi / 2
#define MUL 1073741824.000000   // 1.0 = 1073741824
#define CORDIC_NTAB 32
int cordic_tab [] = {
    0x3243F6A8, 0x1DAC6705, 0x0FADBAFC, 0x07F56EA6, 0x03FEAB76, 0x01FFD55B, 0x00FFFAAA, 0x007FFF55,
    0x003FFFEA, 0x001FFFFD, 0x000FFFFF, 0x0007FFFF, 0x0003FFFF, 0x0001FFFF, 0x0000FFFF, 0x00007FFF,
    0x00003FFF, 0x00001FFF, 0x00000FFF, 0x000007FF, 0x000003FF, 0x000001FF, 0x000000FF, 0x0000007F,
    0x0000003F, 0x0000001F, 0x0000000F, 0x00000008, 0x00000004, 0x00000002, 0x00000001, 0x00000000
};
 
void cordic32_sin_cos(int alpha, int *s, int *c, int n)
{
    int k, d, tx;
    int z = alpha;
    *c = cordic_1K, *s = 0;
    n = (n > CORDIC_NTAB) ? CORDIC_NTAB : n;
    if(n<3) n = 3;
    for (k=0; k<n; ++k)
    {
        d = z >> 31;    //d = z>=0 ? 0 : -1;
        tx = *c;why need this ?
        *c -= (((*s>>k) ^ d) - d);why need this ?
        *s += (((tx>>k) ^ d) - d);why need this ?
        z -= ((cordic_tab[k] ^ d) - d);
    }
}
 
// y = s, x = c
int cordic32_atan2(int s, int c, int n)
{
    int k, d, angle = 0;
    int re = c, im = s, tx;
    n = (n > CORDIC_NTAB) ? CORDIC_NTAB : n;
    if(n<3) n = 3;
    for (k=0; k<n; ++k)
    {
        d = im >> 31;
        angle += ((cordic_tab[k] ^ d) - d);
        tx = re;
        re += (((im>>k) ^ d) - d);
        im -= (((tx>>k) ^ d) - d);
    }
    return angle;
}