Untitled

<!DOCTYPE html>
<Html>
    <head>
        <meta charset="utf-8">
        <meta name="viewport" width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0>
        <title> BENJAMIN'S     FILE</title>

        <style>
            .divider{
               background-color: teal;
               color: black;
               width: 100px
               height:100px;
               float:left"
            }
            .results{
               background-color: black;
               color: white;
            }.i9m,;lp]

        </style>
    </head>
    <body>
        <form id="jsonFile" name="jsonFile" enctype="multipart/form-data" method="post">
          <fieldset>
            <h2>MISSING DATA WORK WITH FOR BEN</h2>

            <div  class="results" id="maindiv2">
                <h3>Result of IMPUTATION</h3>
                <fieldset>
                   <!--<legend>Console output</legend>-->
                   <p>Select local CSV File:</p>
                    <input type="file" name="TXTField" id="csv" alt="Get text"/>
                    <input type="button" id='get_d_data' value="RUN" onclick="getDs()"/>
                </fieldset>
            </div><br><br>

            <div id="color" class="divider"></div>

            <canvas id="canvas" width=1000 height=1000></canvas>
            <p id="demo"></p>

            </fieldset>
        </form>

        <script>
//******************** THIS PARTITION IS FOR CLUSTERING POINT DATA*************//

            var input = document.getElementById("csv");
            var button = document.getElementById("get_d_data");
            var arrs=[], arrs2=[], arrs3=[], pi=Math.PI, zoom =5;
            var canvas  = document.getElementById('canvas');
            var ctx = canvas.getContext("2d");
            var cw=ctx.width,   ch=ctx.height;
            var mid_lat =0, mid_lng =0, nebors1=[];
            var time_start, gAll=[];

            function Radians(degrees){
                return degrees * (pi/180);
            }

            function convert_lng_x(lng){
                lng=Radians(lng);
                var j=(256/pi)*Math.pow(2, zoom);
                var k=lng + pi ;
                return j*k;
            }

            function convert_lat_y(lat){
                lat=Radians(lat);
                var j=(256/pi)*Math.pow(2, zoom);
                var k=Math.tan(pi/4 +lat/2 );
                var l= pi - Math.log(k);
                return j*l;
            }

            function getDs() {
                console.log("Fetching selected file.............");
                var reader = new FileReader();
                reader.onload = function () {
                    var data= reader.result;
                    //console.log(x);
                    var MainArray = data.split('\n');
                    //check(MainArray);
                    loose(MainArray);
                };
                // start reading the file. When it is done, calls the onload event defined above.
                reader.readAsBinaryString(input.files[0]);
            };

            function loose(x){
                console.log("Extracting require training set.......");
                var g=[], qt=[], qt1=[];
                //console.log(x);
                //************ FOR NON LAT-LONG DATASETS

                for(var i=0, x1=x.length;i<x1; i++){
                    var x2 = x[i]
                    var v =x2.split(",");
                    //console.log(v)
                    var j= v[1], j1=v[2], j3=new Point(parseFloat(j), parseFloat(j1));
                    g.push(j3);
                    //g=g.filter(g => g.x < 200 && g.y < 250 )
                }
                check(g)

                //************ FOR LAT-LONG DATASETS
                /*var cx=convert_lng_x(mid_lng);
                var cy=convert_lat_y(mid_lat);
                console.log([cx, cy]);
                for(var i=0, x1=x.length; i<x1; i++){
                    var x2 = x[i].split(",")
                    //console.log(x2);
                    let lng=x2[2];
                    let lat=x2[1];
                    let lng2=parseFloat(convert_lng_x(lng))-(cx-100)
                    let lat2=parseFloat(convert_lat_y(lat))-(cx-300)
                    //console.log([lng2, lat2]);
                    let p =new Point(lng2, lat2);
                    qt.push(p);

                    let lng3=parseFloat(convert_lng_x(lng))-(cx-100);
                    let lat3=parseFloat(convert_lat_y(lat))-(cx-500);
                    let p1 =new Point(lng3, lat3);
                    qt1.push(p1);
                }
                //console.log(qt);
                remove (qt, qt1);*/
            }
            function sets (maingroups1  ){
                var maingroups=[];
                while(maingroups1.length>0){
                    let jk=maingroups1.slice(0, 50)
                    maingroups.push(jk)
                    maingroups1.splice(0, 50)
                }
                return(maingroups)
            }

            function remove(maingroups){
                console.log("Running proposed model and IMPUTING MV...");
                var eachGroup,  base=[], d, sum, sum1, meanp, meanp1;

                for(var i=0, i4=maingroups.length; i< i4; i++){
                    var eachGroup=maingroups[i];
                    //datap.forEach(function(el){display(el.x, el.y, 2, "black", "black")});
                    //console.log(eachGroup)
                    var datal=eachGroup.length, rem=0, krem=0;
                    var rem2=Math.ceil((3/100)*datal);
                    var rem3=Math.ceil((6/100)*datal);
                    var rem4=Math.ceil((9/100)*datal);
                    var rem5=Math.ceil((12/100)*datal);
                    var rem6=Math.ceil((15/100)*datal);
                    var dataratio=[rem2, rem3, rem4, rem5, rem6]
                    var d=dataratio.length;

//******************** ****************************************************************CALCULATE RATIO
//******************************************************************** CALCULATE RATIO

                    var findMean=function(eachGroup){

                        let sumx = eachGroup.reduce(function (accumulator, currentValue) {
                           return accumulator + currentValue.x ;
                        }, 0);

                        let sumy = eachGroup.reduce(function (accumulator, currentValue) {
                           return accumulator + currentValue.y;
                        }, 0);

                        let meanx=sumx /datal
                        let meany=sumy /datal

                        return [meanx, meany]
                    }

                    var extract =function(eachGroup, r) {

                        var finalL=[], v, mv=[], mvpoints=[], misingv=[], misingvi=[];
                        var randinx, misingvi4;

                        while(rem <r){
                            let rand =Math.random()
                            randinx=Math.floor(rand* datal)
                            if(!eachGroup[randinx]){break};
                            misingvi.splice(rem, 1, randinx)
                            eachGroup.splice(randinx, 1)
                            dData=eachGroup[randinx]
                            mvpoints.push(dData)
                            rem++
                            misingvi4=[mvpoints, misingvi]
                        }
                        return misingvi4
                    }


//*********************************************************************START EXECUTION OF MODEL
//******************************************************START EXECUTION OF MODEL
                    var mainv=function (eachGroup, r3){

                        let ext=extract(eachGroup, r3)
                        let originalv=ext[0]
                        let originalv1=ext[1]

                        // ****************if  subtractig from the mean
                        k=findMean(eachGroup)
                         let k2=k[0]


                        // *********if not subtractig from the mean
                        if (originalv.length ==0){return false}
                        let xoriginalv=originalv.map(g=> g.x - k2);
                        //let xoriginalv=originalv.map(g=> g.x);
                        let yoriginalv=originalv.map(g=> g.y);
                        //console.log(xoriginalv)

                        newpoints=[xoriginalv, originalv1]
                        return newpoints;
                    }

                    var model=function(eachGroup, rem2){

                       let pp=mainv(eachGroup, rem2);
                       var mainval=pp[0], mainvali=pp[1];
                       console.log(mainval)

                       let meanG=findMean(eachGroup)
                       var X2= meanG[0], X3=meanG[1];


                       let xyList=[(Math.log(X2)/10), (Math.log(X3)/10)]//**if you will subtract from mean
                       console.log(Math.log(X2))

                       //let xyList=[3*(Math.log(X2)), 3*(Math.log(X3))]
                       let computedx=[mainval, mainvali, xyList[0], xyList[1]];
                       return computedx
                    }

                    var modelcomp=function (eachGroup, rem2){
                        var avg;
                        var A, missingindex, x, y, B;
                        let dmodel=model(eachGroup, rem2);
                        initialvals=dmodel[0];

                        var initialvalsAvg = initialvals.reduce((b, c) =>{A=initialvals.length
                            return b +c;
                        }, 0)
                        avg =initialvalsAvg/initialvals.length

                        missingindex=dmodel[1];
                        x=dmodel[2];
                        y=dmodel[3];
                        B=missingindex.length

                        let point2= new Point(x, y)
                        for (var f =0, f1= B; f<f1; f++){
                            let t=missingindex[f]
                            eachGroup.splice(t, 0, point2);
                        }
                        let sumOfv=initialvals.reduce((accumulated, Z) => {
                            let x1=x
                            let s1=Z-x1;
                            let s2=Math.pow(s1, 2);
                            return accumulated + s2
                        } , 0)

                        let sumOfv1=initialvals.reduce((accumulated, Z) => {
                            let x2=Math.abs(x-avg)
                            let s3=Math.abs(Z-avg);
                            let s5=x2+s3
                            let s2=Math.pow(s5, 2);
                            return accumulated + s2
                        } , 0)
                        return [sumOfv, B, sumOfv1];
                    }
                    let Q=modelcomp(eachGroup, rem5)
                    base.push(Q)
                }
                return base;
            }

            function check(dmainPoints){
                console.log("process start...");
                time_start = new Date().getTime();

                let dmainPoints1 = sets(dmainPoints)

                let s=remove(dmainPoints1)

                let finals = s.reduce((sti, sto) => {
                    let g =sti+sto[0]
                    return g
                }, 0)

                let finali = s.reduce((sti, sto) => {
                    let g =sti+sto[1]
                    return g
                }, 0)

                let finald = s.reduce((sti, sto) => {
                    let g =sti+sto[2]
                    return g
                }, 0)
                //console.log( finald)

                let y=finals/finali
                let y2=Math.sqrt(y)

                let y1=[finals, finali]

                //********************Compute d2
                var y3=1-(finals/finald)
                console.log(y3);
                //  var dataratio=[rem2, rem3, rem4, rem5, rem6]
                //var dataratio=[3, 6, 9, 12, 15]

                console.log('\n');
                console.log("The final RSME for 3 % is", y2)

                var duration = new Date().getTime() - time_start;
                console.log("process finished.......");
                console.log('Processed in: ' + duration + 'ms');
            }

            class Point{
                constructor(x, y){
                    this.x = x != null ? x : 0;
                    this.y = y != null ? y : 0;
                    this.z = undefined;
                    this.dim=[this.x, this.y, this.z];
                }
                create(){
                    return new Point(this.x, this.y);
                }

            }

            function display(x, y, size, color, f){
                ctx.fillStyle = f;
                ctx.beginPath();
                ctx.lineWidth = "2";
                ctx.strokeStyle = color;
                ctx.arc(x, y, size, 0, 2 * Math.PI);
                ctx.stroke();
                ctx.fill();
                    //console.log(el);
            }