Calculating (\$a^2\$ + \$b(2c-d)^2)/(3e)\$ in assembly I made a simple assembly program to evaluate the function

$$f =\frac{a^2 + b(2c-d)^2}{3e}$$

Since this is basically my first ever, I would like to hear what I can improve and know how to use registers better.

.model small
.stack 100h
.data 
a dw 4
b dw 15
c dw 86
d dw 155
e dw 8 
res dw 0;
.code
mov ax,@data
mov ds,ax
mov dx,0 
mov bx,0 
mov cx,0
mov ax,c
shl ax,1
mov bx,d
sub ax,bx
mul ax
mul b
mov dx,ax
push dx
mov dx,0
mov ax,a
mul ax
pop cx
add ax,cx
mov dx,ax
push dx
mov dx,0
mov ax,e
mov bx,3
mul bx
mov bx,ax
pop cx
mov ax,cx
mov cx,bx
div cx 
mov ax,4c00h
int 21h
end
Some registers have a basic purpose and they supposed to be used for those but it's not that you can't use cx for storing arithmetic operation result. There are few things you could improve in your code
Comment
I would really recommend you to start putting comments. Assembly is not a difficult language but it's very context specific. Each similar looking assembly line might be doing different thing depending on the context and comments are important, even in such small application codebase as this one. Do not try to write what the instruction does in english like
add ax,cx ;adds content of cx to ax 

but rather explain the meaning.
add ax,cx ;after that ax  = a^2 + b(2*c - d)^2

Assembly
As I wrote above there's nothing wrong in your usage of assembly (unless you use some register that can't be used - like segment ones), but there are few things you could optimize.
mov ax,0 

could be written as xor ax,ax and saved few bytes (only if you want to). And you don't have to zero ax &amp; cx as you don't use it before you assign any value to it.
This is a strange construct too:
mov dx,ax 
push dx  
mov dx,0

You are moving the result from calculation to dx to push in to the stack and then clearing the register. Why not just
push ax

Instructions at the end also looks like they are doing too much of moving around so this could be simplified as:
mov ax,e
mov bx,3
mul bx
mov bx,ax
pop ax
div bx

You are writing that you want to use registers more so those push/pop could also be removed. Also res is unsued in the code - remove it.
Final program (probably - could be even more improved)
.model small
.stack 100h
.data 
a dw 4
b dw 15
c dw 86
d dw 155
e dw 8 
.code
_start:
  mov ax,@data
  mov ds,ax

  xor dx,dx 
  mov ax,c
  shl ax,1  ; ax = 2*c

  mov bx,d
  sub ax,bx ; ax = 2*c - d
  mul ax    ; ax = (2*c - d)^2
  mul b     ; ax = b*(2*c - d)^2
  mov cx,ax

  xor dx,dx
  mov ax,e  
  mov bx,3
  mul bx    ; ax = 3*e
  mov bx,ax

  mov ax,a    
  mul ax    ; ax = a^2   
  add ax,cx ; cx = a^2 + b*(2*c - d)^2

  div bx    ; ax = (a^2 + b*(2*c - d)^2)/3e

  mov ax,4c00h
  int 21h
end _start