main project java code

Program/f.txt

+Age & Integer, Single & Boolean, Sugar & ss, Blood_Type & String, Pressure & Double, Eye_Colour & String, Leukocyte & Integer, Safe & Boolean
+     60      ,        0        ,     85.7      ,         O+         ,       12.3       ,        brown       ,        9376        ,       0       , High
+     54      ,      false      ,     43.2      ,         B+         ,       10.1       ,        blue        ,        11248       ,     true      , Low
+     23      ,        1        ,     40.3      ,         AB-        ,       9.4        ,        gray        ,        10900       ,       1       , Low
+     46      ,        0        ,     m.5     ,         O-         ,       16.7       ,        brown       ,        10244       ,     false     , High
+     29      ,        0        ,     38.5      ,         A+         ,       10.8       ,        black       ,        10750       ,       0       , Low
+     t       ,      true       ,     77.8      ,         AB+        ,       13.6       ,        green       ,        10083       ,       1       , High
+     29      ,        0        ,     38.5      ,         A+         ,       10.8       ,        black       ,        10750       ,       0       , Low
+     35      ,      true       ,     77.8      ,         AB+        ,       13.6       ,        green       ,        10083       ,       1       , High
\ No newline at end of file

Program/file.txt

+Double&sugar ,String&pressure,Integer&Iron ,String&liver ,Integer&Pigment ,Integer&Vitamen-D ,Integer&Leukocyte
+56.0         ,blue           ,560          ,blue        ,560    ,low
+10.3         ,yellow         ,13           ,yellow      ,13    ,high
+70.8         ,white          ,70           ,white       ,70    ,low
+10.3         ,yellow         ,13           ,yellow      ,13    ,high
+60.3         ,red            ,603    ,red    ,603    ,high
+232.0    ,blue    ,23    ,blue    ,23    ,low
+232.0    ,blue    ,23    ,blue    ,23    ,low
+120.3    ,red    ,13    ,red    ,13    ,high
+10.8    ,white    ,108    ,white    ,108    ,low
+10.8    ,white    ,108    ,white    ,108    ,low
+120.3    ,red    ,13    ,red    ,13    ,high
+10.3    ,yellow    ,13    ,yellow    ,13    ,high
+10.3    ,yellow    ,13    ,yellow    ,13    ,high
+56.0    ,blue    ,560    ,blue    ,560    ,low
+60.3    ,red    ,603    ,red    ,603    ,high
+232.0    ,blue    ,23    ,blue    ,23    ,low
+10.3    ,yellow    ,13    ,yellow    ,13    ,high
+60.3    ,red    ,603    ,red    ,603    ,high
+10.8    ,white    ,108    ,white    ,108    ,low
+120.3    ,red    ,13    ,red    ,13    ,high
+120.3    ,red    ,13    ,red    ,13    ,high
+232.0    ,blue    ,23    ,blue    ,23    ,low
+0.3    ,yellow    ,3    ,yellow    ,3    ,high
+0.3    ,yellow    ,3    ,yellow    ,3    ,high
+0.3    ,yellow    ,3    ,yellow    ,3    ,high
+120.3    ,red    ,13    ,red    ,13    ,high
+0.3    ,yellow    ,3    ,yellow    ,3    ,high
+70.8    ,white    ,70    ,white    ,70    ,low
+10.3    ,yellow    ,13    ,yellow    ,13    ,high
+120.3    ,red    ,13    ,red    ,13    ,high
+232.0    ,blue    ,23    ,blue    ,23    ,low
+10.8    ,white    ,108    ,white    ,108    ,low
+232.0    ,blue    ,23    ,blue    ,23    ,low
+56.0    ,blue    ,560    ,blue    ,560    ,low
+56.0    ,blue    ,560    ,blue    ,560    ,low
+10.8    ,white    ,108    ,white    ,108    ,low
+0.3    ,yellow    ,3    ,yellow    ,3    ,high
+70.8    ,white    ,70    ,white    ,70    ,low
+10.8    ,white    ,108    ,white    ,108    ,low
+232.0    ,blue    ,23    ,blue    ,23    ,low
+70.8    ,white    ,70    ,white    ,70    ,low
+10.3    ,yellow    ,13    ,yellow    ,13    ,high
+70.8    ,white    ,70    ,white    ,70    ,low
+70.8    ,white    ,70    ,white    ,70    ,low
+10.8    ,white    ,108    ,white    ,108    ,low
+56.0    ,blue    ,560    ,blue    ,560    ,low
+120.3    ,red    ,13    ,red    ,13    ,high
+10.8    ,white    ,108    ,white    ,108    ,low
+120.3    ,red    ,13    ,red    ,13    ,high
+10.8    ,white    ,108    ,white    ,108    ,low

Program/file1

+Integer&sugar ,String&pressure,Double&Iron ,Integer&liver ,Integer&Pigment ,Integer&Vitamen-D ,Integer&Leukocyte
+t             , 49            , 55 , 64 , 68 , 58 , 20 ,  High 
+44            , 15            , 21 , 02 , 66 , 65 , 54 ,  High 
+14            , 00            , 55 , 11 , 43 , 25 , 54 ,  High 
+51            , 07            , 16 , 11 , 33 , 00 , 68 ,  High 
+62            , 12            , 64 , 00 , 46 , 13 , 26 ,  High 
+34            , 34            , 68 , 42 , 25 , 05 , 47 ,  High 
+14            , 41            , 10 , 54 , 69 , 67 , ,  High 
+17            , 44            , 05 , 29 , 23 , 37 , 42 ,  nograde 
+10            , 08            , 55 , 25 , 08 , 40 , 20 ,  High 
+09            , 65            , 07 , 60 , 16 , 02 , 08 ,  High 
+27            , 44            , 00 , 17 , 40 , 29 , 13 ,  High 
+59            , 05            , 45 , 42 , 56 , 56 , 04 ,  High 
+48            , 12            , 42 , 51 , 67 , 02 , 50 ,  High 
+14            , 23            , 48 , 44 , 62 , 38 , 28 ,  High 
+44            , 58            , 07 , 02 , 54 , 44 , 01 ,  High 
+77            , 86            , 94 , 88 , 79 , 98 , 90 ,  Low 
+59            , 97            , 80 , 66 , 96 , 86 , 85 ,  Low 
+51            , 69            , 78 , 57 , 61 , 84 , 80 ,  Low 
+65            , 62            , 68 , 61 , 91 , 92 , 88 ,  Low 
+87            , 58            , 59 , 88 , 76 , 90 , 86 ,  Low 
+58            , 84            , 88 , 73 , 78 , 97 , 88 ,  Low 
+98            , 76            , 86 , 90 , 81 , 66 , 98 ,  Low 
+76            , 89            , 98 , 86 , 82 , 88 , 68 ,  Low 
+54            , 61            , 54 , 87 , 54 , 77 , 72 ,  Low 
+69            , 85            , 98 , 72 , 95 , 53 , 63 ,  Low 
+81            , 62            , 59 , 59 , 82 , 76 , 54 ,  Low 
+96            , 53            , 56 , 96 , 78 , 82 , 72 ,  Low 
+68            , 63            , 63 , 92 , 76 , 78 , 80 ,  Low 
+81            , 52            , 82 , 70 , 86 , 92 , 74 ,  Low 
+61            , 91            , 77 , 90 , 92 , 96 , 80 ,  Low 
+94            , 56            , 80 , 90 , 82 , 67 , 59 ,  Low 
+54            , 85            , 54 , 98 , 83 , 94 , 91 ,  Low 
+81            , 96            , 74 , 88 , 93 , 67 , 55 ,  Low 
+66            , 73            , 96 , 71 , 96 , 90 , 71 ,  Low 
+62            , 99            , 60 , 78 , 59 , 86 , 65 ,  Low
+71            , 92            , 56 , 51 , 83 , 79 , 78 ,  Low 
+97            , 99            , 75 , 90 , 80 , 81 , 97 ,  Low 
+55            , 94            , 51 , 93 , 57 , 66 , 91 ,  Low 
+78            , 83            , 56 , 70 , 74 , 63 , 76 ,  Low 
+75            , 71            , 63 , 75 , 72 , 53 , 87 ,  Low 
+79            , 76            , 79 , 80 , 97 , 82 , 74 ,  Low 
+66            , 95            , 85 , 74 , 84 , 82 , 57 ,  Low 
+61            , 75            , 57 , 78 , 99 , 77 , 63 ,  Low 
+92            , 90 , 54 , 61 , 82 , 95 , 52 ,  Low 
\ No newline at end of file

Program/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>medicalAnalysis</groupId>
+    <artifactId>Program</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>15</maven.compiler.source>
+        <maven.compiler.target>15</maven.compiler.target>
+        <exec.mainClass>medicalanalysis.program.Program</exec.mainClass>
+    </properties>
+</project>
\ No newline at end of file

Program/src/main/java/medicalanalysis/program/DataCollect/DataLoader.java

+
+
+package medicalanalysis.program.DataCollect;
+
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.DataCollect.History;
+import medicalanalysis.program.DataException.NotCompleteDataException;
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+import java.util.StringTokenizer;
+import java.util.ArrayList;
+import java.io.IOException;
+import java.lang.Class;
+import java.lang.reflect.Constructor;
+import java.lang.ClassNotFoundException;
+import java.lang.reflect.InvocationTargetException;
+
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+
+public class DataLoader {
+    
+    public static History  dataloader(String path )throws IOException{
+        
+        History Sample=new History ();
+        try  {
+           BufferedReader br = new BufferedReader(new FileReader(path)) ;
+           String line;
+           
+           line=br.readLine();
+           
+           readTestNames(line,Sample);
+           
+           readFieldType(line,Sample);
+           
+           int dataLength =Sample.getType().size()+1;
+           
+         
+           while ((line = br.readLine()) != null) {
+           
+               Patient p ;
+               try {
+        
+                   p=PatientLoader(line,dataLength,Sample);
+                  
+                   if(p!=null){
+                       
+                       Sample.setPatients(p);
+                       
+                   }
+                 
+               }
+               catch(NotCompleteDataException e1 ){
+                   System.out.println("\nInvalid Data  in line : "+line);
+                   System.out.println("the line length is : "+line.length());
+                   System.out.println("the error is : "+e1.getLocalizedMessage());
+                   
+                   
+        
+               }
+               
+               
+            }
+           System.out.println("the data loaded from the file   ");
+         
+        }catch(IOException e){
+         
+            // throw the ioexception to the upper function 
+            // because in the current level we cannot do any thing 
+            
+            throw e ;
+         
+        }catch(Exception e )/*in case happend an eception we not expect it */{
+              System.out.println(e.getMessage());
+              
+        }
+       finally {
+         // finally if the file found or not 
+         // we should close the connection
+         
+         //sbr.close();
+         System.out.println("the  file connection closed  ");
+                 
+            
+        
+                 }
+        
+       
+        return Sample;
+    }
+    
+    public static Patient PatientLoader(String values,int l ,History s )throws NotCompleteDataException ,ClassNotFoundException ,Exception/*change it */ {
+        Patient p =new Patient ();
+
+        ArrayList<String>data =new ArrayList();
+
+        data=(split(values,","));
+
+        
+        if(data.size()==l){
+            
+            for(int i =0;i<data.size()-1;i++){
+              
+                String value=data.get(i).replaceAll("\\s", "");
+                
+                String type=s.getType(i);
+                  Feature f;
+                // incase the data were  boolean so replace 1 into true and so 
+                value=(type.equals("java.lang.Boolean"))? (value.equals("1")||value.equals("true"))?"True":"False" :value;
+              
+                try{
+                  f=new Feature(type,value);//to create an instacne from Featue of Type (type)and Value (value)
+                                                  //this function throws exceptions 
+                                                  //ClassNotFoundException,InstantiationException,IllegalAccessException,InvocationTargetException
+     
+               }catch(ClassNotFoundException e1 ){
+                   
+                  System.out.println("errors occcurs :unKnown Class " +e1.getMessage()+"\n"); 
+                  System.out.println("the Class replaced with java.lang.String \n"); 
+                  s.setType("java.lang.String",i);
+                  type=s.getType(i);
+                   f= new Feature(type,value);
+                      
+                  
+               }
+               catch(InvocationTargetException e2 ){
+                  
+                   System.out.println("\nInvalid Data   for constructor \nData is : "+value+"\ntype of data should be :"+type);
+                   System.out.println("the line length is : "+l);
+                   
+                   if(e2.getCause().getClass().getName().equals("java.lang.NumberFormatException")){
+                       f= new Feature(type,"0");
+                         System.out.println("and replaced with  : 0");
+                   
+                      
+                   }else{
+                       return null;
+                   }
+               
+                   
+               }
+                
+               
+            
+                //   System.out.println(f);
+                   
+            p.add(f);
+            }   
+            if(data.get(data.size()-1).toLowerCase().replaceAll("\\s", "").equals("high")|| 
+                    data.get(data.size()-1).toLowerCase().replaceAll("\\s", "").equals("low")){
+         
+            throw new NotCompleteDataException(values,"not complete data ",data.size(),"illegal gread");
+                     
+        }
+            p.setGrade(data.get(data.size()-1).toLowerCase().replaceAll("\\s", ""));
+            
+         return p;
+         
+        }else{
+            
+            throw new NotCompleteDataException(values,"not complete data ",data.size(),"illegal length");
+            
+        }
+        
+        
+        
+        
+   
+    }
+    
+    private static void readFieldType(String line,History Sample ){
+        ArrayList<String >t =new ArrayList();
+        t=split(line,",");
+        //set the type of the data for each feature :==>
+        for(String i : t){
+            Sample.setType("java.lang."+split(i,"&").get(1).replaceAll("\\s", ""));
+            
+        }
+        
+        
+    }
+     
+    private static void readTestNames(String line ,History Sample)/*read the test name in the first line of the file */{
+        int i=0;
+          for(String l : split(line ,",")){
+              Sample.addTest( split(l,"&").get(0));
+              i++;
+              
+          }
+    }
+
+    public static ArrayList<String> split(String line, String delimiter) {
+        ArrayList<String> result = new ArrayList<>();
+       
+        StringTokenizer st = new StringTokenizer(line, delimiter);
+        while (st.hasMoreTokens()) {
+            result.add(st.nextToken());
+            
+       
+        }
+    
+    return result;
+    }
+}

Program/src/main/java/medicalanalysis/program/DataCollect/Feature.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package medicalanalysis.program.DataCollect;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+
+/**
+ *
+ * @author HASASN
+ */
+public class Feature <T> {
+    
+    private T value;//the value of the analysis 
+    
+    /*used this function to create an instance from Feautre for  type(className)and set the value */
+    public static Feature<?> creatInstance(String className, String value)
+            throws NoSuchMethodException ,ClassNotFoundException,InstantiationException
+                                        ,IllegalAccessException,InvocationTargetException
+    {
+        
+        
+        Class c=Class.forName(className);
+        Constructor v=c.getConstructor(String.class);
+       
+        
+       Feature<?>g=new Feature( v.newInstance(value));
+                
+        return g;
+        
+    }
+  
+    public Double getMeasure(){
+        String type=value.getClass().getName();
+        
+       
+        switch(type){
+            case"java.lang.String":return new Double(((String)value).length());
+            
+            case"java.lang.Boolean":return ((Boolean)value)?1.0:0.0;
+            
+            default :{
+                
+                 String t=value.getClass().getGenericSuperclass().getTypeName();
+                if(t.equalsIgnoreCase("java.lang.Number")){
+                    
+                    return ((Number)value).doubleValue();
+                }else{
+                    
+                    return new Double((value.toString()).length());
+                    
+                }
+                
+            }
+            
+        }
+        
+        
+    }
+    
+    public Feature(String className, String value)
+            throws NoSuchMethodException ,ClassNotFoundException,InstantiationException
+                                         ,IllegalAccessException,InvocationTargetException
+    {
+        
+        Class clazz=Class.forName(className);
+        Constructor cons=clazz.getConstructor(String.class);
+        this.value=(T)( cons.newInstance(value));
+        
+        
+    }
+    public Feature(T value) {
+        this.value = value;
+    }
+    public void setValue(T value) {
+        this.value = value;
+    }
+    public T getValue() {
+        return value;
+    }
+    
+    @Override
+    public String toString() {
+        return  value.toString() ;
+    }
+
+    
+}

Program/src/main/java/medicalanalysis/program/DataCollect/History.java

+
+
+
+
+package medicalanalysis.program.DataCollect;
+
+import java.util.ArrayList;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class History {
+    
+    private ArrayList<Patient>  patients ; 
+    private ArrayList<String>         TestName ; // th name of each test 
+    private ArrayList<String>type=new ArrayList();
+
+    public void setType(String type) {
+        this.type.add(type);
+    }
+    public void setType(String type,int i) {
+        this.type.set(i, type);
+    }
+
+    public ArrayList<String> getType() {
+        return type;
+    }
+    public void addTest(String value) {
+         TestName.add( value);
+    }
+    public String getType(int index) {
+        return type.get(index);
+    }
+    private int length ; 
+
+    
+    public ArrayList<Patient> getPatients() {
+       
+        ArrayList<Patient> newInst=new ArrayList<Patient>();
+    
+        return patients;
+    }
+
+    public void setTestName(String TestName ,int index) {
+        this.TestName.set(index, TestName);
+    }
+
+    public ArrayList<String> getTestName() {
+        return TestName;
+    }
+    public String getTestName(int index) {
+        return TestName.get(index);
+    }
+
+    
+    
+
+    public History() {
+        
+        patients=new ArrayList<Patient>();
+        TestName=new ArrayList<String>();
+        
+        
+    }
+
+    public void setPatients(Patient patients) {
+        this.patients.add(patients) ;
+        
+        
+    }
+    
+    
+   public Patient getPatient(int index){
+       
+       return patients.get(index);
+       
+       
+   }   
+   public String toString(){
+       
+       String s ="";
+       for (Patient p : patients ){
+           
+           s+=p.toString();
+       }
+       
+       
+       
+       
+   return s ;
+   }
+   
+    
+}
+

Program/src/main/java/medicalanalysis/program/DataCollect/Patient.java

+
+
+package medicalanalysis.program.DataCollect;
+import java.util.StringTokenizer;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class Patient {
+    
+    private ArrayList<Feature<?>> analysis;//list of analysis each one is from different type 
+    private String grade ;
+    
+    public Patient(){
+        
+        analysis=new ArrayList();
+        grade="Low";
+        
+        
+        
+    }
+    public Patient( ArrayList<Feature<?> > a , String g ){
+      
+        analysis=new ArrayList();
+        for (Feature i : a){
+            analysis.add(new Feature(i));
+        }
+        
+        grade=g;
+        
+        
+    }
+
+    public <T> void  setAnalysis( T value ,int index) {
+        analysis.add(new Feature(value));
+        
+        
+    }
+    public void setGrade(String grade) {
+        this.grade = grade;
+    }
+    
+    public void add(Feature f ){
+        analysis.add(f);
+        
+    }
+    public ArrayList<Feature<?> > getAnalysis() {
+        return analysis;
+    }
+
+    public Feature getAnalysis(int index ) {
+        return analysis.get(index);
+    }
+    public String getGrade() {
+        return grade;
+    }
+
+    @Override
+    public String toString() {
+        String s="Patient : { ";
+        for(Feature i :analysis){
+            s+=i.toString()+" , ";
+        }
+        return  s+" grade = " + grade + '}'+'\n' ;
+    }
+    
+    
+    
+    
+            
+}
+

Program/src/main/java/medicalanalysis/program/DataException/NotCompleteDataException.java

+
+
+package medicalanalysis.program.DataException;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class NotCompleteDataException extends Exception{
+    
+   
+    private String totalLine ;
+
+    public String getTotalLine() {
+        return totalLine;
+    }
+
+    public int getLineSize() {
+        return LineSize;
+    }
+
+    public String getLocalMessage() {
+        return localMessage;
+    }
+    private int LineSize;
+    private String localMessage;
+
+    public NotCompleteDataException( String totalLIne ,int size,String t) {
+        
+        this.totalLine = totalLIne;
+        LineSize=size;
+        this.localMessage=t;
+        
+    }
+
+    public NotCompleteDataException( String totalLIne, String message,int size,String t) {
+        super(message);
+       
+        this.totalLine = totalLIne;
+        LineSize=size;
+        
+        this.localMessage=t;
+        
+    }
+    
+    
+    
+}
+

Program/src/main/java/medicalanalysis/program/Predictor.java

+
+
+package medicalanalysis.program;
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.DataCollect.History;
+import java.util.PriorityQueue;
+import medicalanalysis.program.Similarity.Distancable;
+
+
+/**
+ *
+ * @author HASAN
+ *
+ */
+
+public class Predictor<E extends Distancable> {
+   private final int k_th ;
+   private double miniDist ;
+   private final  Patient userData;
+   private final  History history;
+   private final E similarity ; // the type of distance 
+   
+   
+   public Predictor(int k_th, Patient userData, History history, E similarity) {
+        this.k_th = k_th;
+        this.userData = userData;
+        this.history = history;
+        this.similarity = similarity;
+    }
+   
+   
+   public String  getPrecidt(){
+       
+       String result=new String ("high");      
+       
+       findMinDistance(); // to find the  distance of the last k patient that should be added into the predict 
+       
+       result =findMatch(); // get the patient the the distance of them are smaler the the minimum acceptable distance
+                            // and count the grade and return the result
+       
+       return result ;
+   }
+   public Double getDistance(Patient historyPatient ,E dsitanceWay )/*return the distamce between the
+                                                                     user data and the current patient
+                                                                     due to the distance way */{
+       
+       Double dist=new Double(0.0);
+       
+       dist=dsitanceWay.distance(userData,historyPatient);
+       
+       
+       
+       return dist ;
+   }
+   
+   
+   public void findMinDistance(){// to find the  distance of the last k patient that should be added into the predict 
+       
+       
+       PriorityQueue<Double>dist=new PriorityQueue();// to sort the distance of the patients 
+       
+       // add the distance of all the patients  
+       for(Patient p : history.getPatients()){
+           dist.add(getDistance(p,similarity));
+           
+       }
+       
+       // remove the last minimum k -1 distance 
+       for (int i=1;i<k_th;i++){
+           dist.remove();
+           
+       }
+       // get the last k minimum disrance 
+       miniDist=dist.remove();
+    
+       
+   }
+   
+   
+   public String findMatch(){
+       
+       int hNum=0; // number of  high grade 
+       int lNum=0; // number of low grade 
+       int i =1;
+       
+       System.out.println("the minimu Distance is  "+miniDist); 
+       System.out.println("the "+k_th+"_Th nearst patient are :\n"); 
+                   
+       for(Patient p : history.getPatients()){
+           // if the distance between the current patient and user data
+           // is  smaller than the minimum acceptable distance 
+           // then print the patient and count the grade 
+           if(getDistance(p,similarity)<=miniDist){
+    
+                   String ss ="high";
+                   
+                   String s2 =p.getGrade();
+                   System.out.println(i+"-"+p.toString()+" "); 
+                   i++;
+                   if((s2.equals(ss))){
+   
+                       
+                   hNum++;
+               }else{
+                       
+                   
+                   lNum++;
+                   
+               }
+           }
+       }
+   // compare the number of high and kow grade and return  the result      
+   return (hNum>=lNum) ? "High" :"Low";
+   }
+       
+
+}

Program/src/main/java/medicalanalysis/program/Program.java

+
+
+
+package medicalanalysis.program;
+
+import medicalanalysis.program.DataCollect.DataLoader;
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.DataCollect.History;
+import medicalanalysis.program.DataCollect.Feature;
+import medicalanalysis.program.Similarity.EcliudDistance;
+import medicalanalysis.program.Similarity.ManhatenDistance;
+import medicalanalysis.program.Similarity.MinkoDistance;
+import java.util.Scanner;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.lang.reflect.InvocationTargetException;
+import medicalanalysis.program.Similarity.Distancable;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class Program {
+  
+    
+    //static variable :
+    
+    public static Scanner myObj = new Scanner(System.in);
+    public static Patient userData = new Patient ();
+    public static int k =10;
+    public static  History history=new History();
+    public static String file = new String ("");   
+    public static  String grade =new String();
+    public static Distancable similarity =new EcliudDistance();   
+    
+
+  
+ public static void main(String[] args)throws Exception {
+    
+     connectToFile();// try to connect to the file and  load the file data  
+    
+     
+     ReadPatientData(userData); // read the patient tests 
+  
+     setKTH();
+     
+     choseDistance();// chose the type of the distance minkowski ,ecuild or manhaten 
+  
+     Predictor newPrediction  = new Predictor(k,userData,history ,similarity);//the main algorithm of prediction
+        
+     grade=newPrediction.getPrecidt();// get the predict
+     
+     System.out.println(" the result is : "+grade);
+     
+  /*  */  
+    }
+ private static  void connectToFile(){
+     
+        
+        
+     System.out.println("Enter the File Path ");
+     file =myObj.nextLine();
+     try {
+         
+        history=DataLoader.dataloader(file);//try to load the data 
+     }
+        
+     catch(IOException e  )/*catch the faild of file open */{
+            
+        System.out.println("uncorrect file path ,\nEnter e backup file or re write the file name   ");
+        String backup =new String("default_file_path.txt ");
+        backup =myObj.nextLine();
+        
+        try{
+                 history=DataLoader.dataloader(backup); 
+        }
+        
+        catch(IOException e1 ){
+            
+            System.out.println("un correct file and backup ,  ");
+          
+            System.exit(0);
+        }
+        
+            
+        }
+    finally{//finally we should to close the file connection
+            
+       // System.out.println(" the file connection colsed ");
+                 
+            
+        }
+                
+     
+        
+    }
+ private static void choseDistance(){
+        
+       System.out.println("-Enter \n1- to Eculidane Distance \n2- to Minko Distance \n3- to Manhaten Distance  ");
+       
+        String value =myObj.nextLine();
+        switch(value){
+            case "1" : similarity =new EcliudDistance ()  ;  break ; 
+            case "2" : similarity =new MinkoDistance ()   ; break ; 
+            default : similarity =new  ManhatenDistance ()  ;  break ; 
+            
+            
+        }
+         
+        
+        
+    }
+ private static void setKTH(){
+      
+     System.out.println("-\nEtner the K th :");
+     try{
+         k=Integer.parseInt(myObj.nextLine());
+         
+         if(k>history.getPatients().size()||k<=0||k%2==0){
+             System.out.println("the K is more than the size of data");
+             k=1;
+             
+         }
+     }catch(NumberFormatException e ){
+         System.out.println("-\nuncorrect value to  the K th :");
+         k=1;
+     }
+     
+ }
+ public static void ReadPatientData(Patient p ){
+        
+    for (int i=0;i<history.getType().size();i++){
+        // read data ==>>X
+        System.out.println("Enter test "+history.getTestName(i)+" value :");
+
+        String userData = myObj.nextLine();  // Read user input
+      
+        try{
+            Feature f =new Feature(history.getType(i),userData);
+            p.add(f);
+            
+        }catch(Exception e ){
+                
+            System.out.println(userData+" is Invalid data reEnter the number ");
+            i--;
+                
+        }
+    }
+        
+        
+}
+
+    
+}
+
+

Program/src/main/java/medicalanalysis/program/Similarity/Distancable.java

+
+
+package medicalanalysis.program.Similarity;
+
+import medicalanalysis.program.DataCollect.Patient;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public interface Distancable{
+    
+    public double distance(Patient user ,Patient other );
+    
+    
+}
+

Program/src/main/java/medicalanalysis/program/Similarity/EcliudDistance.java

+
+
+package medicalanalysis.program.Similarity;
+
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.Similarity.Distancable;
+
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class EcliudDistance implements Distancable {
+    
+    public double distance(Patient user ,Patient other){
+        Double dist =new  Double(0.0);
+        
+        for(int i=0;i<user.getAnalysis().size();i++){
+            
+            double x=user.getAnalysis(i).getMeasure()-other.getAnalysis(i).getMeasure();
+            dist+=x*x;
+            
+        }
+        dist=Math.sqrt(dist);
+        return dist;
+    }
+    
+}

Program/src/main/java/medicalanalysis/program/Similarity/ManhatenDistance.java

+
+
+package medicalanalysis.program.Similarity;
+
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.Similarity.Distancable;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class ManhatenDistance implements Distancable {
+    
+    public double distance(Patient user ,Patient other){
+        Double dist =new  Double(0.0);
+        
+        for(int i=0;i<user.getAnalysis().size();i++){
+            
+            dist+=Math.abs(user.getAnalysis(i).getMeasure()-other.getAnalysis(i).getMeasure());
+            
+            
+        }
+        
+        return dist;
+    }
+}
+

Program/src/main/java/medicalanalysis/program/Similarity/MinkoDistance.java

+
+
+
+package medicalanalysis.program.Similarity;
+
+import java.util.Scanner;
+import medicalanalysis.program.DataCollect.Patient;
+import medicalanalysis.program.Similarity.Distancable;
+
+/**
+ *
+ * @author HASAN
+ * 
+*/
+public class MinkoDistance implements Distancable{
+    private static int p=3; //parametre to minko distance 
+    public double distance(Patient user ,Patient other){
+        Double dist =new  Double(0.0);
+        
+        
+        
+        for(int i=0;i<user.getAnalysis().size();i++){
+            
+            dist+=Math.pow(Math.abs(user.getAnalysis(i).getMeasure()-other.getAnalysis(i).getMeasure()), p);
+            
+            
+        }
+        double P=1.0/p;
+       
+        
+        dist=Math.pow(dist, P);
+            
+        return dist;
+    }
+}

Program/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

+medicalanalysis\program\NotCompleteDataException.class
+medicalanalysis\program\Program.class
+medicalanalysis\program\EcliudDistance.class
+medicalanalysis\program\MinkoDistance.class
+medicalanalysis\program\ISimilarity.class
+medicalanalysis\program\ManhatenDistance.class
+medicalanalysis\program\Patient$prediction.class
+medicalanalysis\program\DataLoader.class
+medicalanalysis\program\History.class
+medicalanalysis\program\Patient.class
+medicalanalysis\program\Predict.class

Program/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\NotCompleteDataException.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\History.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\DataLoader.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\MinkoDistance.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\EcliudDistance.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\ISimilarity.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\Patient.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\Predict.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\Program.java
+C:\Users\USER\Desktop\Program\src\main\java\medicalanalysis\program\ManhatenDistance.java