Algorithm:  
def circle_area(loop_num):  
    set the radius `r` of the circle;  
    create a circle whose center is the origin;  
    create a boudning box with points (-r,-r), (r,-r), (r,r), (-r,r);

    set counter = 0; #count the total number of points generatedhe circle;  

    set in_counter = 0; #count the number of points inside the circle

    for(i = 0 to loop_num):  
        counter = counter + 1; 
        
        create random real number x in (-r,r)  
        create random real number y in (-r,r)


        if (x^2 + y^2) < r^2:  
            in counter = in_counter + 1;

    return (counter/in_counter)*(4*r*r)

Algorithm:  
def pi():

    using MCM to approximate the area `S` of a circle with radius `r` which is
    what we have done in previous section.

    return S/(r*r)

Algorithm:  
def ellipse_area(loop_num):

    set focus c and the major semi axis a;  
    a must be greater than c;
    b = sqrt(a^2 - c^2);  
    create an ellipse;  
    create a boudning box with points (-a,-b), (a,-b), (a,b), (-a,b);

    set counter = 0; #count the total number of points generatedhe circle;  
    set in_counter = 0; #count the number of points inside the circle

    for(i = 0 to loop_num):  
        counter = counter + 1; 


        create random real number x in (-a,a)  
        create random real number y in (-b,b)


        if (x^2/a^2 + y^2/b^2) < 1:  
            in counter = in_counter + 1;

    return (counter/in_counter)*(4*a*b)

def intersection_check(pointA, pointB, x, y){

    # this algorithm will check whether segment AB has an intersection with the horizontal ray starting from (x,y) to the right infinity 

    #Parameters:
    #pointA and pointB are the start and end point of the line.
    #x, y is the point when want to check whether inside the polygon or out side the polygon
    
    create a ray R which start from point (x,y) and goes to the right infinity point (100, y).
    
    # if line AB is vertical
    if(pointA.X() == pointB.X()){
        # line AB is vertical. Vertical line does not has equation y = ax +b.
        if(r_x<pointA.X() && y > min{pointA.Y(), pointB.Y()} && y < max{pointA.Y(), pointB.Y()}){
            # r_x<pointA.X(): the test point is on the left side      
            # y > min{pointA.Y(), pointB.Y()} && y < max{pointA.Y(), pointB.Y()}: the test point is within the Y range of segment AB.
            return true;                    
        }       
        else{
            return false;    
        }    
    }
    
    # calculate a and b (line equation: y = ax + b)
        a = ( pointA.Y() - pointB.Y() )/( pointA.X() - pointB.X() );    # a = (y1 - y2)/(x1 - x2)
        b = pointA.Y() - a*pointA.X();      #b = y1 - ax1

    
    # if line AB is horizontal
        if(a == 0){
            # the line will parallel with the ray 
            
            if ( x>=min{pointA.Y(), pointB.Y()} && x<=max{pointA.Y(), pointB.Y()} && y == pointA.Y()) {
                # x>=min{pointA.Y(), pointB.Y()} && x<=max{pointA.Y(): the test point is within the X range of segment AB.
                # y == pointA.Y(): point (x,y) has the same y value with segment AB            
                # the test point is just on segment AB.        
                return true;  
            }
            else{
                return false;    <!-- there is no intersection point -->
            }
        }

    
    # then the horizontal line will have an intersection with line AB
    # calculate the x coordinate of the intersection with the horizontal line
    inter_x = (b-y)/(0-a); # intersection of line y = ax + b and line y = y'
    
    # the intersection point will be (inter_x, y)

    if( inter_x>=min{pointA.Y(), pointB.Y()} && inter_x<=max{pointA.Y(), pointB.Y()} && inter_x>x){
        # inter_x>=min{pointA.Y(), pointB.Y()} && inter_x<=max{pointA.Y(), pointB.Y()}: check whether inter_x is within the X range of segment AB
        # check whether inter_x within the range and in the right side of random point
        return true;
    }
    else{

        return false;
    }

}

def in_out_checking(x, y, points){

    #this function will check whether point (x,y) is inside the polygon composed by
    
    #Parameters:
    #(x, y) is the point we want to test
    #points is a list contains all the points of a polygon. 
    # ex.[A,B,C] means the three vertexes of a triangle 
    
    
    #the number of intersections composed by the horizontal ray and the polygon 
    
    intersection_num = 0;       

    # in the following loop, for every edge of the polygon, we will check if it will
    # intersect with the ray. If there is, we will add the counter by 1
    
    for(i=0; i<points.length; i++){

        # check the last line,for example: for polygon [A,B,C]. the last line is CA 
        if(i !== points.length - 1){
            line = [ [points[i].X(), points[i].Y()] , [points[i+1].X(), points[i+1].Y()] ];

            if(intersection_check(line, x, y)){
                intersection_num = intersection_num + 1;
            }

        }
        # check the rest lines    
        else{
            line = [ [ points[points.length-1].X(), points[points.length-1].Y() ] , [points[0].X(), points[0].Y()] ];     <!-- lines are expressed using two points -->

            if(intersection_check(line, r_x, r_y)){
                intersection_num = intersection_num + 1;
            }
        }
    }
    # if the intersection number is odd, then the point is inside the polygon 
    if(intersection_num % 2 === 1){
        return true;
    }
    # if the intersection number is even, then the point is outside the polygon
    else{
        return false;
    }

}

Algorithm:  
def polygon_monte(loop_num, polygon_points):

    #firstly, we need to create a bounding box
    set as minX the minimum x coordinate inside polygon_points.
    set as minY the minimum Y coordinate inside polygon_points.
    set as maxX the maximum X coordinate inside polygon_points.
    set as maxY the maximum Y coordinate inside polygon_points.
    
    create bounding box using points [(minX, minY), (maxX, minY), (maxX, maxY), (minX, maxY)]
        

    set counter = 0; # count the total number of points generated  

    set in_counter = 0; # count the number of points inside the circle

    for(i = 0 to loop_num):  
        counter = counter + 1; 
        
        create random real number x in (minX,maxX)  
        create random real number y in (minY,maxY)


        if in_out_checking(x, y, polygon_points):  
            in counter = in_counter + 1;

    return (counter/in_counter)*((maxX-minX)*(maxY-minY))