(x1,y1)

(x2,y2)

(x3,y3)

x=sqrt(pow(x1-x2,2)+pow(y1-y2))

package triangle;

public class Triangle {
    private double x1;
    private double x2;
    private double x3;
    private double y1;
    private double y2;
    private double y3;
    
    public Triangle(double x1,double y1,double x2,double y2,double x3,double y3){
        this.x1=x1;
        this.x2=x2;
        this.x3=x3;
        this.y1=y1;
        this.y2=y2;
        this.y3=y3;
    }
    public boolean isTriangler() {
        if(x1==x2&&y1==y2||x1==x3&&y1==y3||x3==x2&&y3==y2)//not distnict
            return false;
        double[] lengths=lengths();
        if(lengths[0]==lengths[1]+lengths[2]||lengths[1]==lengths[0]+lengths[2]||lengths[2]==lengths[1]+lengths[0])//parallel
            return false;
        return true;
    }
    public double[] lengths() {
        double lengths[]=new double[3];
        lengths[0]=Math.sqrt(Math.pow(x1-x2, 2)+Math.pow(y1-y2, 2));
        lengths[1]=Math.sqrt(Math.pow(x2-x3, 2)+Math.pow(y2-y3, 2));
        lengths[2]=Math.sqrt(Math.pow(x3-x1, 2)+Math.pow(y3-y1, 2));        
        return lengths;

    }
    public String isScalene() {
        double lengths[]=lengths();
        if(lengths[0]!=lengths[1]&&lengths[1]!=lengths[2]&&lengths[0]!=lengths[2])
            return "scalene";
        else
            return "isosceles";
    }
    public String classify() {
        double lengths[]=lengths();
        double A=Math.floor(Math.pow(lengths[0], 2)+.00005);
        double B=Math.floor(Math.pow(lengths[1], 2)+.00005);
        double C=Math.floor(Math.pow(lengths[2], 2)+.00005);
        double D=Math.floor(Math.pow(lengths[1], 2)+Math.pow(lengths[2], 2)+.00005);
        double E=Math.floor(Math.pow(lengths[0], 2)+Math.pow(lengths[2], 2)+.00005);
        double F=Math.floor(Math.pow(lengths[1], 2)+Math.pow(lengths[0], 2)+.00005);
        System.out.println(A+"="+D);
        System.out.println(B+"="+E);
        System.out.println(C+"="+F);
        if(A==D||B==E||C==F)
            return "right";
        else if(Math.pow(lengths[0], 2)>Math.pow(lengths[1], 2)+Math.pow(lengths[2], 2)
                ||Math.pow(lengths[1], 2)>Math.pow(lengths[0], 2)+Math.pow(lengths[2], 2)
                ||Math.pow(lengths[2], 2)>Math.pow(lengths[1], 2)+Math.pow(lengths[0], 2))
            return "obtuse";
        else
            return "acute";
    }
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            double x1=Double.parseDouble(args[i]);
            i++;
            double y1=Double.parseDouble(args[i]);
            i++;
            double x2=Double.parseDouble(args[i]);
            i++;
            double y2=Double.parseDouble(args[i]);
            i++;
            double x3=Double.parseDouble(args[i]);
            i++;
            double y3=Double.parseDouble(args[i]);
            Triangle t=new Triangle(x1,y1,x2,y2,x3,y3);
            double[] lengths=t.lengths();
            for (int j = 0; j < lengths.length; j++) {
                System.out.println(lengths[j]+" ");
            }
            System.out.println();
            if(t.isTriangler()){
                StringBuilder s=new StringBuilder(" triangle");
                s.insert(0," " + t.classify());
                s.insert(0,t.isScalene());
                System.out.println(s.toString());
            }
            else
                System.out.println("not a triangle");
        }
    }
    public double getX1() {
        return x1;
    }
    public void setX1(double x1) {
        this.x1 = x1;
    }
    public double getX2() {
        return x2;
    }
    public void setX2(double x2) {
        this.x2 = x2;
    }
    public double getX3() {
        return x3;
    }
    public void setX3(double x3) {
        this.x3 = x3;
    }
    public double getY1() {
        return y1;
    }
    public void setY1(double y1) {
        this.y1 = y1;
    }
    public double getY2() {
        return y2;
    }
    public void setY2(double y2) {
        this.y2 = y2;
    }
    public double getY3() {
        return y3;
    }
    public void setY3(double y3) {
        this.y3 = y3;
    }

}

double A=Math.floor(Math.pow(lengths[0], 2)+.00005);

package triangle;

public class Triangle {
    private Point a;
    private Point b;
    private Point c;
    
    public Triangle(Point a,Point b,Point c){
        this.a=a;
        this.b=b;
        this.c=c;
    }
    public boolean isTriangler() {
        if(a.Getx()==b.Getx()&&a.Gety()==b.Gety()||a.Getx()==c.Getx()&&a.Gety()==c.Gety()||c.Getx()==b.Getx()&&c.Gety()==b.Gety())//not distnict
            return false;
        double[] lengths=lengths();
        if(lengths[0]==lengths[1]+lengths[2]||lengths[1]==lengths[0]+lengths[2]||lengths[2]==lengths[1]+lengths[0])//parallel
            return false;
        return true;
    }
    public double[] lengths() {
        double lengths[]=new double[3];
        lengths[0]=Math.sqrt(Math.pow(a.Getx()-b.Getx(), 2)+Math.pow(a.Gety()-b.Gety(), 2));
        lengths[1]=Math.sqrt(Math.pow(b.Getx()-c.Getx(), 2)+Math.pow(b.Gety()-c.Gety(), 2));
        lengths[2]=Math.sqrt(Math.pow(c.Getx()-a.Getx(), 2)+Math.pow(c.Gety()-a.Gety(), 2));        
        return lengths;

    }
    public String isScalene() {
        double lengths[]=lengths();
        if(lengths[0]!=lengths[1]&&lengths[1]!=lengths[2]&&lengths[0]!=lengths[2])
            return "scalene";
        else
            return "isosceles";
    }
    public String classify() {
        double lengths[]=lengths();
        double A=Math.floor(Math.pow(lengths[0], 2)+.00005);
        double B=Math.floor(Math.pow(lengths[1], 2)+.00005);
        double C=Math.floor(Math.pow(lengths[2], 2)+.00005);
        double D=Math.floor(Math.pow(lengths[1], 2)+Math.pow(lengths[2], 2)+.00005);
        double E=Math.floor(Math.pow(lengths[0], 2)+Math.pow(lengths[2], 2)+.00005);
        double F=Math.floor(Math.pow(lengths[1], 2)+Math.pow(lengths[0], 2)+.00005);
        System.out.println(A+"="+D);
        System.out.println(B+"="+E);
        System.out.println(C+"="+F);
        if(A==D||B==E||C==F)
            return "right";
        else if(Math.pow(lengths[0], 2)>Math.pow(lengths[1], 2)+Math.pow(lengths[2], 2)
                ||Math.pow(lengths[1], 2)>Math.pow(lengths[0], 2)+Math.pow(lengths[2], 2)
                ||Math.pow(lengths[2], 2)>Math.pow(lengths[1], 2)+Math.pow(lengths[0], 2))
            return "obtuse";
        else
            return "acute";
    }
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            double x1=Double.parseDouble(args[i]);
            i++;
            double y1=Double.parseDouble(args[i]);
            i++;
            double x2=Double.parseDouble(args[i]);
            i++;
            double y2=Double.parseDouble(args[i]);
            i++;
            double x3=Double.parseDouble(args[i]);
            i++;
            double y3=Double.parseDouble(args[i]);
            Triangle t=new Triangle(new Point(x1,y1),new Point(x2,y2),new Point(x3,y3));
            double[] lengths=t.lengths();
            for (int j = 0; j < lengths.length; j++) {
                System.out.println(lengths[j]+" ");
            }
            System.out.println();
            if(t.isTriangler()){
                StringBuilder s=new StringBuilder(" triangle");
                s.insert(0," " + t.classify());
                s.insert(0,t.isScalene());
                System.out.println(s.toString());
            }
            else
                System.out.println("not a triangle");
        }
    }
}

package triangle;

public class Point
{
    private double x;
    private double y;
    public Point()
    {
        x = y = 1;
    }
    public Point(double x1, double y1)
    {
        x = x1;
        y = y1;
    }
    public Point(Point p)
    {
        x = p.x;
        y = p.y;
    }
    public void ReadPoint()
    {
        
    }
    public void PrintPoint()
    {
        
    }
    public void SetPoint(double x1, double y1)
    {
        x = x1;
        y = y1;
    }
    public double Getx()
    {
        return x;
    }
    public double Gety()
    {
        return y;
    }
    
}

if(((A.x-B.x)==0 && (A.y-B.y)==0) || ((C.x-B.x)==0 && (C.y-B.y)==0) || ((A.x-C.x)==0 && (A.y-C.y)==0))

int fsum = L1*L2*L3;
if ( fsum=Math.pow(L1,3)
{
System.out.println("Equilateral Triangle");
}

...      
int Line[2];
int LineInput[6];
int n(0);

Line[0]=Math.sqrt(pow((A.x)-(B.x),2)+Math.pow((A.y)-(B.y),2)); // A----B
Line[1]=Math.sqrt(pow((A.x)-(C.x),2)+Math.pow((A.y)-(C.y),2)); // A----C
Line[2]=Math.sqrt(pow((C.x)-(B.x),2)+Math.pow((C.y)-(B.y),2)); // B----C
      

//---------------------------------------

LineInput[0]=Line[0]-Line[1];    
LineInput[1]=Line[0]-Line[2];
LineInput[2]=Line[1]-Line[0];
LineInput[3]=Line[1]-Line[2];
LineInput[4]=Line[2]-Line[0];
LineInput[5]=Line[2]-Line[1];

//-----------------------------------------    

    for(int i=0; i<6; i++)
               {

                                  if(LineInput[i]==0)
            ++n;
           }

               if(n==6)
    
        System.out.println("Equilateral Triangle");

                         else if(n==2)  
    
                 System.out.println("Isosceles Triangles")
    
                                  else { System.out.println("scalene") }

}

d1=L1-L2
d2=L2-L3
d3=L3-L1

c1= [(y2-y1)*(a-x1)-(x2-x1)*(b-y1)] * [(y2-y1)*(x3-x1)-(x2-x1)*(y3-y1)]
c2= [(y3-y1)*(a-x1)-(x3-x1)*(b-y1)] * [(y3-y1)*(x2-x1)-(x3-x1)*(y2-y1)]
c3= [(y3-y2)*(a-x2)-(x3-x2)*(b-y2)] * [(y3-y2)*(x1-x2)-(x3-x2)*(y1-y2)]

(y2-y1)*(x-x1)-(x2-x1)*(y-y1)=0

public class droite {
    public float a;
    public float b;
    public float c;
// معادلة من الشكل
// ax+by+c=0


// ميل المستقيم
    public float ponte;


// Constructor

//إنشاء مستقيم بدون أية معطيات
    public droite()
    {
        a=b=c=ponte=0;
        
    }

// إنشاء مستقيم بإدخال المعطيات الثلاثة
    public droite(float A,float B, float C)
    {
        a=A;
        b=B;
        c=C;
        if (b!=0)  ponte= -a/b; else ponte=Float.MAX_VALUE;
        
    }

//  إنشاء مستقيم  بدلالة نقطتين
    public  droite(float x1,float y1,float x2,float y2)
    {
        float A= (y2-y1)/(x2-x1);
        float B=y1-A*x1;
        a=A;
        b=-1;
        c=B;
        if (b!=0)  ponte= -a/b; else ponte=Float.MAX_VALUE;

    }

// معرفة مكان نقطة بالمقارنة بمستقيم
// 1 : فوق
// -1: تحت
// 0: تنتمي إلى المستقيم
    public  int position(float x,float y)
    {
        
        
        float reslut = (a*x+b*y+c);

        
        if (reslut*ponte==Float.MAX_VALUE) return -1;
        if(ponte==0){
            if (y>0) return 1;
            if (y<0) return -1;
            return 0;
        }
            
        if(ponte>0)
        {
        if (reslut*ponte<0) return 1;// audessus
        if (reslut*ponte>0) return -1;// audesous
        }
        else
        {
            if (reslut*ponte>0) return 1;// audessus
            if (reslut*ponte<0) return -1;// audesous
        }
    
    

        return 0;//  sur
        
        
    }

}

    public boolean pointIn(float x,float y)
     {
//ننشئ ثلاث مستقيمات  الخاصة بالمثلث
         droite drt1 = new droite(x1,y1,x2,y2);
         droite drt2 = new droite(x1,y1,x3,y3);
         droite drt3 = new droite(x2,y2,x3,y3);
        
        
         if((drt1.position(x, y)==1)&&((drt2.position(x, y)==1))&&((drt3.position(x, y)==1))) return false;
         if((drt1.position(x, y)!=1)&&((drt2.position(x, y)!=1))&&((drt3.position(x, y)!=1))) return false;
        
         return true;
     }

if (reslut*ponte==Float.MAX_VALUE) return -1;

class WhereIsPoint {

private:
int c1,c2,c3;

public:
WhereIsPoint();

int Method_a(int,int,int,int,int,int,int,int);
int Method_b(int,int,int,int,int,int,int,int);
int Method_c(int,int,int,int,int,int,int,int);

}; //end class

WhereIsPoint::WhereIsPoint()
{
c1=0; c2=0; c3=0;
}
int WhereIsPoint::Method_a(int y1,int y2,int y3, int x1, int x2,int x3,int a,int b)
{
c1= ((y2-y1)*(a-x1)-(x2-x1)*(b-y1)) * ((y2-y1)*(x3-x1)-(x2-x1)*(y3-y1));

return c1;
}
int WhereIsPoint::Method_b(int y1,int y2,int y3, int x1, int x2,int x3,int a,int b)
{
c2= ((y3-y1)*(a-x1)-(x3-x1)*(b-y1)) * ((y3-y1)*(x2-x1)-(x3-x1)*(y2-y1));

return c2;
}

int WhereIsPoint::Method_c(int y1,int y2,int y3, int x1, int x2,int x3,int a,int b)
{
c3= ((y3-y2)*(a-x2)-(x3-x2)*(b-y2)) * ((y3-y2)*(x1-x2)-(x3-x2)*(y1-y2));
return c3;
}

int main()
{
  WhereIsPoint one;
int y1,y2,y3;
int x1,x2,x3;
int a,b;

System.in.println("enter the first point");
  x1=System.in.readInt();
  y1=System.in.readInt();
  
System.in.println("enter the second point");
  x2=System.in.readInt();
  y2=System.in.readInt();
  
System.in.println("enter the third point");
  x3=System.in.readInt();
  y3=System.in.readInt();
  
  System.in.println("enter the Target point");
  a=System.in.readInt();
  b=System.in.readInt();


/* now  */


if(one.Method_a(y1,y2,y3,x1,x2,x3,a,b)>0 && one.Method_b(y1,y2,y3,x1,x2,x3,a,b)>0&& one.Method_c(y1,y2,y3,x1,x2,x3,a,b)>0)
System.out.println(" Point is inside");
else if(one.Method_a(y1,y2,y3,x1,x2,x3,a,b)<0||one.Method_b(y1,y2,y3,x1,x2,x3,a,b)<0||one.Method_c(y1,y2,y3,x1,x2,x3,a,b)<0)
System.out.println(" Point is outside");
else
System.out.println(" Point is Tangent");

    
  return 0;
}

public int pointPosition(float a , float b)
      {
  
  //in:1
  //on:0
  //out:-1
      float c1,c2,c3;
      
      c1 = ((y2-y1)*(a-x1)-(x2-x1)*(b-y1)) * ((y2-y1)*(x3-x1)-(x2-x1)*(y3-y1));
      c2= ((y3-y1)*(a-x1)-(x3-x1)*(b-y1)) * ((y3-y1)*(x2-x1)-(x3-x1)*(y2-y1));
      c3= ((y3-y2)*(a-x2)-(x3-x2)*(b-y2)) * ((y3-y2)*(x1-x2)-(x3-x2)*(y1-y2));
      
      if((c1>0)&&(c2>0)&&(c3>0)) return 1;
      if((c1<0)||(c2<0)||(c3<0)) return -1;
      return 0;
      }

class Triangle {

// fields
private float x1;
private float x2;
private float x3;
private float y1;
private float y2;
private float y3;

// methods
public void A(float valx,float valy);
public void B(float valx,float valy);
public void C(float valx,float valy);
public boolean  IsTriangler();
public int pointPosition(float a,float b);
        // type_name hisType(*V);  
        }