Merge remote-tracking branch 'origin/master'

# Conflicts:
#	app/build.gradle

app/src/main/AndroidManifest.xml

@@ -26,6 +26,12 @@
         android:supportsRtl="true"
         android:usesCleartextTraffic="true"
         android:theme="@style/Theme.ProbabilityAndStatisticsAnalyserAndEducator">
+        <activity android:name=".calculationfunction.EssayTypeNormalDistribution"></activity>
+        <activity android:name=".calculationfunction.NormalDistributionCalculation" />
+        <activity android:name=".calculationfunction.IndepeEssayTypeProCalc" />
+        <activity android:name=".calculationfunction.DepEssayTypeProbabilityCalculation" />
+        <activity android:name=".calculationfunction.ProbablilityCalculation" />
+        android:theme="@style/Theme.ProbabilityAndStatisticsAnalyserAndEducator">
         <activity android:name=".adaptiveLearning.VideoHandler"></activity>
         <activity android:name=".adaptiveLearning.VideoController" />
         <activity android:name=".adaptiveLearning.CourseHandler" />

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/DesStatCalculation.java

@@ -22,6 +22,7 @@ public class DesStatCalculation {
     //median calculation
     double mid;
     public ArrayList<Object> Median(String[] a ) {
+        //create array list for store the values for parsing values to fragment
         ArrayList<Object> list = new ArrayList<>();
         double[] invalue = new double[a.length];
       //  System.out.println("Invaue in median:"+Arrays.toString(invalue));
@@ -338,10 +339,8 @@ double firstQuartile;
         double mean;
         double sumOftheDataset = 0;
         int noofElement = 0 ;
-
         double[] invalue = new double[a.length];
         for(int k = 0; k < a.length; k++){
-
             //System.out.println(a[k].trim());
             try {
                 invalue[k] = Double.parseDouble(a[k].trim());
@@ -349,8 +348,7 @@ double firstQuartile;
                 e.printStackTrace();
             }
         }
-
-      //  System.out.println(Arrays.toString(invalue));
+        //  System.out.println(Arrays.toString(invalue));
         for (double i : invalue) {
             sumOftheDataset = sumOftheDataset + i;
             noofElement++;
@@ -363,7 +361,6 @@ double firstQuartile;
         list.add(1,noofElement);
         list.add(2,roundedFloat);
         list.add(3,invalue);
-
         //System.out.println("mean"+ mean);
         return  list;
 

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/DescriptiveStatisticsCalcuation.java

@@ -31,16 +31,20 @@ public class DescriptiveStatisticsCalcuation extends AppCompatActivity {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_descriptive_statistics_calcuation);
 
+
+        //Fragment manager method (control fragment activity)
         FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
 
         Bundle bundle = new Bundle();
 
+        //from extracted data get the  values
         Intent intent = getIntent();
         array = intent.getStringArrayExtra("dataset");
 
         //create DestatCalculation object
         DesStatCalculation desStaCalculation = new DesStatCalculation();
 
+        //create ArrayList for all calculations
         ArrayList<Object> meanlist = new ArrayList<Object>();
         ArrayList<Object> modelist = new ArrayList<Object>();
         ArrayList<Object> medianlist = new ArrayList<Object>();

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/EssayTypeDescriptiveStaticQuestion.java

@@ -45,11 +45,6 @@ public class EssayTypeDescriptiveStaticQuestion extends AppCompatActivity {
     FrameLayout mninelayout;
 
 
-
-
-
-
-
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -108,10 +103,10 @@ public class EssayTypeDescriptiveStaticQuestion extends AppCompatActivity {
 
         Intent intent1 = getIntent();
         extractDatasetForEssayArray = intent1.getStringArrayExtra("extractDatasetForEssayArray");
-        System.out.println("StandardDeviationextractDatasetForEssayArray"+Arrays.toString(extractDatasetForEssayArray));
-        System.out.println("lengthstd:"+extractDatasetForEssayArray.length);
+        //System.out.println("StandardDeviationextractDatasetForEssayArray"+Arrays.toString(extractDatasetForEssayArray));
+       // System.out.println("lengthstd:"+extractDatasetForEssayArray.length);
         extractedKeywordsFromFuzzy =intent1.getStringExtra("extractedKeywordsFromFuzzy");
-        System.out.println("StandardDeviationextractedKeywordsFromFuzzy"+extractedKeywordsFromFuzzy);
+       // System.out.println("StandardDeviationextractedKeywordsFromFuzzy"+extractedKeywordsFromFuzzy);
 
 
 //---------------------------Descriptive statistics calculation-------------------------------------------------------------------------

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/EssayTypeNormalDistribution.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.fragment.app.FragmentTransaction;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.FrameLayout;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.AboveXFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.BelowXFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.BetweenFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.MeanOfDistributionFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.StandardDeviationDistributionFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.VarianceOfDistributionFragment;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class EssayTypeNormalDistribution extends AppCompatActivity {
+   double extractDatasetForEssayArray;
+    String extractedKeywordsFromFuzzy;
+    double extractDatasetForEssayArray1;
+    double extractDatasetForEssayArray3;
+    String extractedKeywordsFromFuzzy1;
+
+
+
+    //ProbabilityDistribution framelayout
+    FrameLayout mabovelayout;
+    FrameLayout mbelowlayout;
+    FrameLayout mbetweenlayout;
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_essay_type_normal_distribution);
+
+        FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
+
+        //create bundle for normal distribution calculation
+        Bundle abovebundle = new Bundle();
+        Bundle belowbundle = new Bundle();
+        Bundle betweenbundle = new Bundle();
+
+        //intialize the layout normal Distribution calculation
+        mabovelayout=findViewById(R.id.one);
+        mbelowlayout=findViewById(R.id.two);
+        mbetweenlayout=findViewById(R.id.three);
+
+
+        //create string arraylisy for store keywords
+        ArrayList<String> keywordlist = new ArrayList<>();
+
+        //create object for normal distribution
+        NormalDistributionCalc normalDistributionCalc = new NormalDistributionCalc();
+        ArrayList<Object> Abovelist = new ArrayList<Object>();
+        ArrayList<Object> Belowlist = new ArrayList<Object>();
+        ArrayList<Object> Betweenlist = new ArrayList<Object>();
+
+        Intent intent1 = getIntent();
+        //extractDatasetForEssayArray = intent1.getStringArrayExtra("extractDatasetForEssayArray");
+        //  System.out.println("ProDisextractDatasetForEssayArray:-"+ Arrays.toString(extractDatasetForEssayArray));
+        //  System.out.println("LengthofProDta:"+extractDatasetForEssayArray.length);
+        extractedKeywordsFromFuzzy =intent1.getStringExtra("extractedKeywordsFromFuzzy");
+        //  System.out.println("ProDisextractedKeywordsFromFuzzy:-"+extractedKeywordsFromFuzzy);
+        ///extractDatasetForEssayArray1=intent1.getStringArrayExtra("extractDatasetForEssayArray1");
+        //  System.out.println("ProDisextractDatasetForEssayArray1:-"+Arrays.toString(extractDatasetForEssayArray1));
+
+
+
+
+
+        //----------------------Probability Distribution-----------------------------------------------------------------------------------------------------------
+        if((extractedKeywordsFromFuzzy.contains("Standard" ) && extractedKeywordsFromFuzzy.contains("Deviation")) || (extractedKeywordsFromFuzzy.contains("standard" ) && extractedKeywordsFromFuzzy.contains("deviation")) || extractedKeywordsFromFuzzy.contains("σ") || ((extractedKeywordsFromFuzzy1.contains("Standard" ) && extractedKeywordsFromFuzzy1.contains("Deviation")) || (extractedKeywordsFromFuzzy1.contains("standard" ) && extractedKeywordsFromFuzzy1.contains("deviation")) || extractedKeywordsFromFuzzy1.contains("σ"))) {
+            Abovelist=normalDistributionCalc.Probability_X_Greaterthan_Values(extractDatasetForEssayArray,extractDatasetForEssayArray1,extractDatasetForEssayArray3);
+            keywordlist.add("Standard Deviation");
+        }
+        if(extractedKeywordsFromFuzzy.contains("Variance") || extractedKeywordsFromFuzzy.contains("variance") || extractedKeywordsFromFuzzy.contains("σ²") ||(extractedKeywordsFromFuzzy1.contains("Variance") || extractedKeywordsFromFuzzy1.contains("variance") || extractedKeywordsFromFuzzy1.contains("σ²"))){
+            Belowlist=normalDistributionCalc.Probability_X_Greaterthan_Values(extractDatasetForEssayArray,extractDatasetForEssayArray1,extractDatasetForEssayArray3);
+            keywordlist.add("Variance");
+        }
+        if(extractedKeywordsFromFuzzy.contains("Mean") || extractedKeywordsFromFuzzy.contains("mean") ||(extractedKeywordsFromFuzzy1.contains("Mean") || extractedKeywordsFromFuzzy1.contains("mean"))){
+            Betweenlist=normalDistributionCalc.Probability_X_Between_Values(extractDatasetForEssayArray,extractDatasetForEssayArray1,extractDatasetForEssayArray3,extractDatasetForEssayArray);
+            keywordlist.add("Mean");
+        }
+
+
+
+        //------------------Probability Distribution------------------------------------------------------------------------
+        if(keywordlist.contains("Standard Deviation")){
+            abovebundle.putDouble("X_Value", (Double) Abovelist.get(0));
+            abovebundle.putDouble("Mean_Value", (Double) Abovelist.get(1));
+            abovebundle.putDouble("SD_Value", (Double) Abovelist.get(2));
+            abovebundle.putDouble("Z_Value", (Double) Abovelist.get(3));
+            abovebundle.putDouble("Final_Value", (Double) Abovelist.get(4));
+
+
+
+            AboveXFragment aboveXFragment = new AboveXFragment();
+            aboveXFragment.setArguments(abovebundle);
+            fragmentTransaction.add(R.id.one, aboveXFragment);
+
+
+
+        }
+
+        if(keywordlist.contains("Mean")){
+            belowbundle.putDouble("X_Value", (Double) Belowlist.get(0));
+            belowbundle.putDouble("Mean_Value", (Double) Belowlist.get(1));
+            belowbundle.putDouble("SD_Value", (Double) Belowlist.get(2));
+            belowbundle.putDouble("Z_Value", (Double) Belowlist.get(3));
+            belowbundle.putDouble("Final_Value", (Double) Belowlist.get(4));
+
+
+
+            BelowXFragment belowXFragment = new BelowXFragment();
+            belowXFragment.setArguments(belowbundle);
+            fragmentTransaction.add(R.id.two, belowXFragment);
+
+        }
+
+        if(keywordlist.contains("Variance")){
+            betweenbundle.putDouble("X1_Value", (Double) Betweenlist.get(0));
+            betweenbundle.putDouble("X2_Value", (Double) Betweenlist.get(5));
+            betweenbundle.putDouble("Mean_Value", (Double) Betweenlist.get(1));
+            betweenbundle.putDouble("SD_Value", (Double) Betweenlist.get(2));
+            betweenbundle.putDouble("Z1_Value", (Double) Betweenlist.get(3));
+            betweenbundle.putDouble("Z2_Value", (Double) Betweenlist.get(4));
+            betweenbundle.putDouble("Final_Value", (Double) Betweenlist.get(6));
+            betweenbundle.putDouble("Z1_dividedvalue", (Double) Betweenlist.get(7));
+            betweenbundle.putDouble("Z2_dividedvalue", (Double) Betweenlist.get(8));
+
+
+
+
+
+            BetweenFragment betweenFragment = new BetweenFragment();
+            betweenFragment.setArguments(betweenbundle);
+            fragmentTransaction.add(R.id.three, betweenFragment);
+
+        }
+
+        fragmentTransaction.commit();
+    }
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/NormalDistributionCalc.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction;
+
+import java.util.ArrayList;
+
+public class NormalDistributionCalc {
+/*
+    //Type - 1---------Find Normal Distribution P(X > value)-----------------
+    //x=probability value
+    //a=mean
+    //b=standard deviation
+    public ArrayList<Object> Probability_X_Greaterthan_Values(double x, double a,double b) {
+        ArrayList<Object> list = new ArrayList <>();
+
+        //z-score
+        double c;
+        c=(x-a)/b;
+
+
+
+        //double roundedFloat = (double) Math.round(d * 10000.0) / 10000.0;
+
+
+        list.add(0,x);
+        list.add(1,a);
+        list.add(2,b);
+        list.add(3,c);
+        System.out.println("NormalDistribution Type 1:"+ c);
+        return  list;
+
+    }
+
+    //Type - 2---------Find Normal Distribution P(X < value)-----------------
+    //x=probability value
+    //a=mean
+    //b=standard deviation
+    public ArrayList<Object> Probability_X_Lessthan_Values(double x, double a,double b) {
+        ArrayList<Object> list = new ArrayList <>();
+
+        //z-score
+        double c;
+        c=(x-a)/b;
+
+
+
+        //double roundedFloat = (double) Math.round(d * 10000.0) / 10000.0;
+
+
+        list.add(0,x);
+        list.add(1,a);
+        list.add(2,b);
+        list.add(3,c);
+        System.out.println("Normal Distribution Type 2:"+ c);
+        return  list;
+
+    }
+    //Type - 3---------Find Normal Distribution P(X > value)-----------------
+    //x1,x2=probability value
+    //a=mean
+    //b=standard deviation
+    public ArrayList<Object> Probability_X_betweentwo_Values(double x1,double x2, double a,double b) {
+        ArrayList<Object> list = new ArrayList <>();
+
+        //z-score for x1
+        double c1;
+        c1=(x1-a)/b;
+        //z-score for x1
+        double c2;
+        c2=(x2-a)/b;
+
+        //find normal disribution
+        //c2-c1
+
+
+
+        //double roundedFloat = (double) Math.round(d * 10000.0) / 10000.0;
+
+
+        list.add(0,x1);
+        list.add(1,a);
+        list.add(2,b);
+        list.add(3,c1);
+        list.add(4,x2);
+        list.add(5,c2);
+        System.out.println("P(A) independant:"+ c1);
+        return  list;
+
+    }
+*/
+//Type - 1---------Find Normal Distribution above and below x-----------------
+//x=probability value
+//a=mean
+//b=standard deviation
+    public ArrayList<Object> Probability_X_Greaterthan_Values(double x, double a,double b) {
+        ArrayList<Object> list = new ArrayList <>();
+
+        double y,w,Z_MAX=6,z;
+       // a=100;
+        //x=106;
+      //  b=6;
+        if(a<x)
+            y=x-a;
+        else
+            y=a-x;
+        z=y/b;
+        if (z==0.0)
+            x=0.0;
+        else{
+            y=0.5*z;
+            if(y<(Z_MAX*0.5)){
+                x=1.0;
+            }
+            else if (y<1.0){
+                w=y*y;
+                x=((((((((0.000124818987*w-0.001075204047)*w+0.005198775019)*w-0.019198292004)*w+0.059054035642)*w-0.151968751364)*w+0.319152932694)*w-0.531923007300)*w+0.797884560593)*y*2.0;
+            }
+            else{
+                y-=2.0;
+                x=(((((((((((((-0.000045255659*y+0.000152529290)*y-0.000019538132)*y-0.000676904986)*y+0.001390604284)*y-0.000794620820)*y-0.002034254874)*y+0.006549791214)*y-0.010557625006)*y+0.011630447319)*y-0.009279453341)*y+0.005353579108)*y-0.002141268741)*y+0.000535310849)*y+0.999936657524;
+            }
+            if (z>0.0)
+                z=(x+1.0)*0.5;
+            else
+                z=(1.0-x)*0.5;
+        }
+        double roundedFloat = (double) Math.round(z * 10000.0) / 10000.0;
+        list.add(0,x);
+        list.add(1,a);
+        list.add(2,b);
+        list.add(3,z);
+        list.add(4,roundedFloat);
+
+        System.out.println("NormalDistribution Type 1:"+ roundedFloat);
+        return  list;
+
+    }
+    public ArrayList<Object> Probability_X_Between_Values(double x1,double x2, double a,double b) {
+        ArrayList<Object> list = new ArrayList <>();
+
+        double y,w,Z_MAX=6,z1,z2;
+        double zdivide1=(x1-a)/b;
+        double zdivide2=(x2-a)/b;
+        // a=100;
+        //x=106;
+        //  b=6;
+        if(a<x1)
+            y=x1-a;
+        else
+            y=a-x1;
+        z1=y/b;
+        if (z1==0.0)
+            x1=0.0;
+        else{
+            y=0.5*z1;
+            if(y<(Z_MAX*0.5)){
+                x1=1.0;
+            }
+            else if (y<1.0){
+                w=y*y;
+                x1=((((((((0.000124818987*w-0.001075204047)*w+0.005198775019)*w-0.019198292004)*w+0.059054035642)*w-0.151968751364)*w+0.319152932694)*w-0.531923007300)*w+0.797884560593)*y*2.0;
+            }
+            else{
+                y-=2.0;
+                x1=(((((((((((((-0.000045255659*y+0.000152529290)*y-0.000019538132)*y-0.000676904986)*y+0.001390604284)*y-0.000794620820)*y-0.002034254874)*y+0.006549791214)*y-0.010557625006)*y+0.011630447319)*y-0.009279453341)*y+0.005353579108)*y-0.002141268741)*y+0.000535310849)*y+0.999936657524;
+            }
+            if (z1>0.0)
+                z1=(x1+1.0)*0.5;
+            else
+                z1=(1.0-x1)*0.5;
+        }
+        if(a<x2)
+            y=x2-a;
+        else
+            y=a-x2;
+        z2=y/b;
+        if (z2==0.0)
+            x2=0.0;
+        else{
+            y=0.5*z2;
+            if(y<(Z_MAX*0.5)){
+                x2=1.0;
+            }
+            else if (y<1.0){
+                w=y*y;
+                x2=((((((((0.000124818987*w-0.001075204047)*w+0.005198775019)*w-0.019198292004)*w+0.059054035642)*w-0.151968751364)*w+0.319152932694)*w-0.531923007300)*w+0.797884560593)*y*2.0;
+            }
+            else{
+                y-=2.0;
+                x2=(((((((((((((-0.000045255659*y+0.000152529290)*y-0.000019538132)*y-0.000676904986)*y+0.001390604284)*y-0.000794620820)*y-0.002034254874)*y+0.006549791214)*y-0.010557625006)*y+0.011630447319)*y-0.009279453341)*y+0.005353579108)*y-0.002141268741)*y+0.000535310849)*y+0.999936657524;
+            }
+            if (z2>0.0)
+                z2=(x2+1.0)*0.5;
+            else
+                z2=(1.0-x2)*0.5;
+        }
+        double roundedFloat1 = (double) Math.round(z1 * 10000.0) / 10000.0;
+        double roundedFloat12 = (double) Math.round(z2 * 10000.0) / 10000.0;
+        double finalvalue = roundedFloat12-roundedFloat1;
+        list.add(0,x1);
+        list.add(1,a);
+        list.add(2,b);
+        list.add(3,roundedFloat12);
+        list.add(4,roundedFloat1);
+        list.add(5,x2);
+        list.add(6,finalvalue);
+        list.add(7,zdivide1);
+        list.add(8,zdivide2);
+
+
+        System.out.println("NormalDistribution Type 1:"+ finalvalue);
+        return  list;
+
+    }
+
+}

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/NormalDistributionCalculation.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.fragment.app.FragmentTransaction;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.AboveXFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.BelowXFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.BetweenFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.MeanOfDistributionFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.StandardDeviationDistributionFragment;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment.VarianceOfDistributionFragment;
+
+import java.util.ArrayList;
+
+public class NormalDistributionCalculation extends AppCompatActivity {
+    String des_calculation_type;
+    double x,x1,a,b,x2;
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_normal_distribution_calculation);
+
+
+        FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
+
+        Bundle bundle = new Bundle();
+
+        Intent intent = getIntent();
+     //   x1 = intent.getDoubleExtra("dataset");
+        //   x = intent.getDoubleExtra("dataset");
+        //x2 = intent.getDoubleExtra("dataset");
+     //   a = intent.getDoubleExtra("dataset1");
+      //  b= intent.getDoubleExtra("dataset1");
+
+
+        //create NormalDistCalculation object
+        NormalDistributionCalc normalDistributionCalc = new NormalDistributionCalc();
+
+        ArrayList<Object> Abovelist = new ArrayList<Object>();
+        ArrayList<Object> Belowlist = new ArrayList<Object>();
+        ArrayList<Object> Betweenlist = new ArrayList<Object>();
+
+        Abovelist = normalDistributionCalc.Probability_X_Greaterthan_Values(x,a,b);
+        Belowlist=normalDistributionCalc.Probability_X_Greaterthan_Values(x,a,b);
+        Betweenlist=normalDistributionCalc.Probability_X_Between_Values(x1,x2,a,b);
+
+
+        des_calculation_type = intent.getStringExtra("des_calculation_type");
+
+        //switch function
+        switch (des_calculation_type){
+            case "P(X>)":
+                bundle.putDouble("X_Value", (Double) Abovelist.get(0));
+                bundle.putDouble("Mean_Value", (Double) Abovelist.get(1));
+                bundle.putDouble("SD_Value", (Double) Abovelist.get(2));
+                bundle.putDouble("Z_Value", (Double) Abovelist.get(3));
+                bundle.putDouble("Final_Value", (Double) Abovelist.get(4));
+
+
+
+                AboveXFragment aboveXFragment = new AboveXFragment();
+                aboveXFragment.setArguments(bundle);
+                fragmentTransaction.add(R.id.fragment_container, aboveXFragment);
+                fragmentTransaction.commit();
+                break;
+
+            case "P(X<)":
+                bundle.putDouble("X_Value", (Double) Belowlist.get(0));
+                bundle.putDouble("Mean_Value", (Double) Belowlist.get(1));
+                bundle.putDouble("SD_Value", (Double) Belowlist.get(2));
+                bundle.putDouble("Z_Value", (Double) Belowlist.get(3));
+                bundle.putDouble("Final_Value", (Double) Belowlist.get(4));
+
+
+
+                BelowXFragment belowXFragment = new BelowXFragment();
+                belowXFragment.setArguments(bundle);
+                fragmentTransaction.add(R.id.fragment_container, belowXFragment);
+                fragmentTransaction.commit();
+                break;
+
+            case "P(<X<)":
+                bundle.putDouble("X1_Value", (Double) Betweenlist.get(0));
+                bundle.putDouble("X2_Value", (Double) Betweenlist.get(5));
+                bundle.putDouble("Mean_Value", (Double) Betweenlist.get(1));
+                bundle.putDouble("SD_Value", (Double) Betweenlist.get(2));
+                bundle.putDouble("Z1_Value", (Double) Betweenlist.get(3));
+                bundle.putDouble("Z2_Value", (Double) Betweenlist.get(4));
+                bundle.putDouble("Final_Value", (Double) Betweenlist.get(6));
+                bundle.putDouble("Z1_dividedvalue", (Double) Betweenlist.get(7));
+                bundle.putDouble("Z2_dividedvalue", (Double) Betweenlist.get(8));
+
+
+
+
+
+                BetweenFragment betweenFragment = new BetweenFragment();
+                betweenFragment.setArguments(bundle);
+                fragmentTransaction.add(R.id.fragment_container, betweenFragment);
+                fragmentTransaction.commit();
+                break;
+
+
+   /*         case "Solve Essay problem":
+                String [] extractDatasetForEssayArray ;
+                String [] extractDatasetForEssayArray1 ;
+                String extractedKeywordsFromFuzzy1;
+
+
+                //get value from extractDatasetForEssayArray and extractedKeywordsFromFuzzy
+                extractDatasetForEssayArray = intent.getStringArrayExtra("extractDatasetForEssayArray");
+
+                extractedKeywordsFromFuzzy=intent.getStringExtra("extractedKeywordsFromFuzzy");
+
+                extractDatasetForEssayArray1 = intent.getStringArrayExtra("extractDatasetForEssayArray1");
+
+
+
+
+                 System.out.println("desansextractDatasetForEssayArray:-"+Arrays.toString(extractDatasetForEssayArray));
+                 System.out.println("extlength:"+extractDatasetForEssayArray.length);
+                System.out.println("desansextractedKeywordsFromFuzzy:-"+extractedKeywordsFromFuzzy);
+                System.out.println("desansextractDatasetForEssayArray1:-"+Arrays.toString(extractDatasetForEssayArray1));
+                System.out.println("extlength1:"+extractDatasetForEssayArray.length);
+                System.out.println("desansextractedKeywordsFromFuzzy1:-"+extractedKeywordsFromFuzzy1);
+
+                //create intent object for parse the value from DescriptiveStatisticsCalcuation class to  DisplayEssayQuestionAnsWithStepsActivity class
+
+                Intent intent1 =new Intent(ProbabilityDistributionCalculation.this, EssayTypeProDistributionActivity.class);
+                intent1.putExtra("extractDatasetForEssayArray", extractDatasetForEssayArray);
+                intent1.putExtra("extractDatasetForEssayArray1", extractDatasetForEssayArray1);
+                intent1.putExtra("extractedKeywordsFromFuzzy", extractedKeywordsFromFuzzy);
+
+
+
+                //start activity intent1
+                startActivity(intent1);
+*/
+        }
+
+    }
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StandaradDeviationCalculation.java

@@ -26,6 +26,7 @@ public class StandaradDeviationCalculation extends AppCompatActivity {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_standarad_deviation_calculation);
 
+        //object creation
         FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
 
         Bundle bundle = new Bundle();
@@ -33,7 +34,7 @@ public class StandaradDeviationCalculation extends AppCompatActivity {
         Intent intent = getIntent();
         array = intent.getStringArrayExtra("dataset");
 
-//create DestatCalculation object
+//create StdCalculation object
         StdCalculation stdCalculation = new StdCalculation();
 
         ArrayList<Object> populationstdlist = new ArrayList<Object>();

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/A_and_Bpart1Fragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class A_and_Bpart1Fragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPB2;
+    TextView mPAB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPAB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public A_and_Bpart1Fragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_a_and__bpart1,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPAB = view.findViewById(R.id.textview_PAandB);
+        mPAB2 =view.findViewById(R.id.textview_paandb);
+        mfinalanswer=view.findViewById(R.id.finalanswer);
+        mresult =view.findViewById(R.id.result);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+
+
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        Double ProbabilityOFAB = bundle.getDouble("ProbabilityAB_value");
+
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPAB.setText(ProbabilityOFAB.toString());
+        mPAB2.setText(ProbabilityOFAB.toString());
+        mfinalanswer.setText(ProbabilityOFAandB.toString());
+        mresult.setText(ProbabilityOFAandB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+
+
+        if(ProbabilityOFB < ProbabilityOFAB   ) {
+            mfinalanswer.setText("  P(B)  must be greater or equal to P(A and B)");
+            mresult.setText(" P(B)  must be greater or equal to P(A and B)");
+
+        }
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/AandBPart2Fragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class AandBPart2Fragment extends Fragment {
+
+
+    TextView mPA;
+    TextView mPA2;
+    TextView mPAB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPAB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public AandBPart2Fragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_aand_b_part2,container,false);
+
+
+        mPA = view.findViewById(R.id.textview_PB);
+        mPAB = view.findViewById(R.id.textview_PAandB);
+        mPAB2 =view.findViewById(R.id.textview_paandb);
+        mfinalanswer=view.findViewById(R.id.finalanswer);
+        mresult =view.findViewById(R.id.result);
+        mPA2 = view.findViewById(R.id.textview_pbs);
+
+
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        Double ProbabilityOFBA = bundle.getDouble("ProbabilityBA_value");
+
+
+
+        mPA.setText(ProbabilityOFA.toString());
+        mPAB.setText(ProbabilityOFBA.toString());
+        mPAB2.setText(ProbabilityOFBA.toString());
+        mfinalanswer.setText(ProbabilityOFAandB.toString());
+        mresult.setText(ProbabilityOFAandB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+
+
+        if(ProbabilityOFA < ProbabilityOFBA   ) {
+            mfinalanswer.setText("  P(B)  must be greater or equal to P(A and B)");
+            mresult.setText(" P(B)  must be greater or equal to P(A and B)");
+
+        }
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/AboveXFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class AboveXFragment extends Fragment {
+    TextView mmeanvalue;
+    TextView msdvalue;
+    TextView mx1value;
+    TextView mx2value;
+    TextView mx3value;
+    TextView mmean1value;
+    TextView mmean2value;
+    TextView msd1value;
+    TextView mz1;
+    TextView mz2;
+    TextView mfinalanswer;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+    public AboveXFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_above_x,container,false);
+
+
+        mmeanvalue = view.findViewById(R.id.textview_PB);
+        msdvalue = view.findViewById(R.id.textview_PA);
+        mx1value =view.findViewById(R.id.textview_PXvalue);
+        mx2value=view.findViewById(R.id.Xvalue);
+        mx3value =view.findViewById(R.id.textview_xvalues);
+        mmean1value = view.findViewById(R.id.meanvalue);
+        mmean2value = view.findViewById(R.id.textview_meaanalues);
+        msd1value=view.findViewById(R.id.textview_sdalues);
+        mz1=view.findViewById(R.id.textview_zscore);
+        mz2=view.findViewById(R.id.textview_pa);
+        mfinalanswer=view.findViewById(R.id.textview_pbs);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double mean = bundle.getDouble("Mean_Value");
+        Double xvalue = bundle.getDouble("X_Value");
+        Double zvalue = bundle.getDouble("Z_Value");
+        Double sdvalue = bundle.getDouble("SD_Value");
+        Double finalanswer = bundle.getDouble("Final_Value");
+
+
+
+
+        mmeanvalue.setText(mean.toString());
+        msdvalue.setText(sdvalue.toString());
+        mx1value.setText(xvalue.toString());
+        mx2value.setText(xvalue.toString());
+        mx3value.setText(xvalue.toString());
+        mmean1value.setText(mean.toString());
+        mmean2value.setText(mean.toString());
+        msd1value.setText(sdvalue.toString());
+        mz1.setText(zvalue.toString());
+        mz2.setText(zvalue.toString());
+        mfinalanswer.setText(finalanswer.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/AintersectionBDependantEvent.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class AintersectionBDependantEvent extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mPAorB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPA2;
+    TextView mPAorB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public AintersectionBDependantEvent(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_aintersection_b_dependant_event,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPA = view.findViewById(R.id.textview_PA);
+        mPAorB =view.findViewById(R.id.textview_PAorB);
+        mfinalanswer=view.findViewById(R.id.textview_paandb);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+        mPA2 = view.findViewById(R.id.textview_pa);
+        mPAorB2=view.findViewById(R.id.textview_paorbs);
+
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+        if(ProbabilityOFAorB < ProbabilityOFA  || ProbabilityOFAorB < ProbabilityOFB     ) {
+            mfinalanswer.setText("P(A or B) must be greater or equal to P(A) or P(B)");
+            mresult.setText("P(A or B) must be greater or equal to P(A) or P(B)");
+
+        }
+        else {
+            mfinalanswer.setText(ProbabilityOFAandB.toString());
+            mresult.setText(ProbabilityOFAandB.toString());
+        }
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mPAorB.setText(ProbabilityOFAorB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPAorB2.setText(ProbabilityOFAorB.toString());
+
+
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/BelowXFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class BelowXFragment extends Fragment {
+    TextView mmeanvalue;
+    TextView msdvalue;
+    TextView mx1value;
+    TextView mx2value;
+    TextView mx3value;
+    TextView mmean1value;
+    TextView mmean2value;
+    TextView msd1value;
+    TextView mz1;
+    TextView mz2;
+    TextView mfinalanswer;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+    public BelowXFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_below_x,container,false);
+
+
+        mmeanvalue = view.findViewById(R.id.textview_PB);
+        msdvalue = view.findViewById(R.id.textview_PA);
+        mx1value =view.findViewById(R.id.textview_PXvalue);
+        mx2value=view.findViewById(R.id.Xvalue);
+        mx3value =view.findViewById(R.id.textview_xvalues);
+        mmean1value = view.findViewById(R.id.meanvalue);
+        mmean2value = view.findViewById(R.id.textview_meaanalues);
+        msd1value=view.findViewById(R.id.textview_sdalues);
+        mz1=view.findViewById(R.id.textview_zscore);
+        mz2=view.findViewById(R.id.textview_pa);
+        mfinalanswer=view.findViewById(R.id.textview_pbs);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double mean = bundle.getDouble("Mean_Value");
+        Double xvalue = bundle.getDouble("X_Value");
+        Double zvalue = bundle.getDouble("Z_Value");
+        Double sdvalue = bundle.getDouble("SD_Value");
+        Double finalanswer = bundle.getDouble("Final_Value");
+
+
+
+
+        mmeanvalue.setText(mean.toString());
+        msdvalue.setText(sdvalue.toString());
+        mx1value.setText(xvalue.toString());
+        mx2value.setText(xvalue.toString());
+        mx3value.setText(xvalue.toString());
+        mmean1value.setText(mean.toString());
+        mmean2value.setText(mean.toString());
+        msd1value.setText(sdvalue.toString());
+        mz1.setText(zvalue.toString());
+        mz2.setText(zvalue.toString());
+        mfinalanswer.setText(finalanswer.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/BetweenFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class BetweenFragment extends Fragment {
+    TextView mmean1value;
+    TextView mmean2value;
+    TextView mmean3value;
+    TextView mx1value;
+    TextView mx2value;
+    TextView mx3value;
+    TextView mx4value;
+    TextView msd1value;
+    TextView msd2value;
+    TextView msd3value;
+    TextView mdividez1;
+    TextView mdividez2;
+    TextView mdividez3;
+    TextView mdividez4;
+    TextView mzscore1;
+    TextView mzscore2;
+    TextView mzscore3;
+    TextView mzscore4;
+    TextView mfinalanswer;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+    public BetweenFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_between,container,false);
+
+
+
+        mmean1value =view.findViewById(R.id.textview_PB);
+        mmean2value=view.findViewById(R.id.extview_PXvalue2);
+        mmean3value =view.findViewById(R.id.extview_Pmmvalue2);
+        mx1value = view.findViewById(R.id.extview_PXvalue);
+        mx2value = view.findViewById(R.id.textview_PXvalue);
+        mx3value=view.findViewById(R.id.extview_PXvalue1);
+        mx4value=view.findViewById(R.id.extview_PXxvalue2);
+        msd1value =view.findViewById(R.id.extview_Psdvalue);
+        msd2value=view.findViewById(R.id.extview_Psd1value);
+        msd3value =view.findViewById(R.id.textview_PA);
+        mdividez1 = view.findViewById(R.id.extview_PXfinavalue);
+        mdividez2 = view.findViewById(R.id.textview_PXvazue);
+        mdividez3=view.findViewById(R.id.textview_xvalues);
+        mdividez4=view.findViewById(R.id.textview_xvlalues);
+        mzscore1 =view.findViewById(R.id.tetview_sdalues);
+        mzscore2=view.findViewById(R.id.textview_sdalues);
+        mzscore3 =view.findViewById(R.id.textview_pa);
+        mzscore4 = view.findViewById(R.id.textview_xvfalues);
+        mfinalanswer = view.findViewById(R.id.textview_pbs);
+
+
+
+
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double mean = bundle.getDouble("Mean_Value");
+        Double x1value = bundle.getDouble("X1_Value");
+        Double x2value = bundle.getDouble("X2_Value");
+        Double z1value = bundle.getDouble("Z1_Value");
+        Double z2value = bundle.getDouble("Z2_Value");
+        Double sdvalue = bundle.getDouble("SD_Value");
+        Double finalanswer = bundle.getDouble("Final_Value");
+        Double Z1dividedvalue = bundle.getDouble("Z1_dividedvalue");
+        Double Z2dividedvalue = bundle.getDouble("Z2_dividedvalue");
+
+
+
+         mmean1value.setText(mean.toString());
+         mmean2value.setText(mean.toString());
+         mmean3value.setText(mean.toString());
+         mx1value.setText(x1value.toString());
+         mx2value.setText(x2value.toString());
+         mx3value.setText(x1value.toString());
+         mx4value.setText(x2value.toString());
+         msd1value.setText(sdvalue.toString());
+         msd2value.setText(sdvalue.toString());
+         msd3value.setText(sdvalue.toString());
+         mdividez1.setText(Z1dividedvalue.toString());
+         mdividez2.setText(Z2dividedvalue.toString());
+         mdividez3.setText(Z2dividedvalue.toString());
+         mdividez4.setText(Z1dividedvalue.toString());
+         mzscore1.setText(z1value.toString());
+         mzscore2.setText(z2value.toString());
+         mzscore3.setText(z1value.toString());
+         mzscore4.setText(z2value.toString());
+         mfinalanswer.setText(finalanswer.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/DepandantProbablityA_BFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class DepandantProbablityA_BFragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPB2;
+    TextView mPAandB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPAandB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public DepandantProbablityA_BFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_depandant_probablity_a__b,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mPAandB2 =view.findViewById(R.id.textview_paandb);
+        mfinalanswer=view.findViewById(R.id.finalanswer);
+        mresult =view.findViewById(R.id.result);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+
+
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFA_B = bundle.getDouble("ProbabilityA|B_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+
+
+        if(ProbabilityOFB < ProbabilityOFAandB   ) {
+            mfinalanswer.setText("  P(B)  must be greater or equal to P(A and B)");
+            mresult.setText(" P(B)  must be greater or equal to P(A and B)");
+
+        }
+        else {
+            mfinalanswer.setText(ProbabilityOFA_B.toString());
+            mresult.setText(ProbabilityOFA_B.toString());
+        }
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/DependantAunionB.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class DependantAunionB extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mPAandB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPAandB2;
+    TextView mPA2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public DependantAunionB(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_dependant_aunion_b,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAorB);
+        mPA =view.findViewById(R.id.textview_PA);
+        mfinalanswer=view.findViewById(R.id.textview_paandb);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+        mPAandB2 = view.findViewById(R.id.textview_paorbs);
+        mPA2=view.findViewById(R.id.textview_pa);
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+
+        if(ProbabilityOFA < ProbabilityOFAandB  || ProbabilityOFB < ProbabilityOFAandB ) {
+            mfinalanswer.setText(" P(A) or P(B)  must be greater or equal to P(A and B)");
+            mresult.setText("P(A) or P(B)  must be greater or equal to P(A and B)");
+
+        }
+        else {
+            mfinalanswer.setText(ProbabilityOFAorB.toString());
+            mresult.setText(ProbabilityOFAorB.toString());
+        }
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/DependantProbablityB_AFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class DependantProbablityB_AFragment extends Fragment {
+
+
+    TextView mPA;
+    TextView mPA2;
+    TextView mPAandB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPAandB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public DependantProbablityB_AFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_dependant_probablity_b__a,container,false);
+
+
+        mPA = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mPAandB2 =view.findViewById(R.id.textview_paandb);
+        mfinalanswer=view.findViewById(R.id.finalanswer);
+        mresult =view.findViewById(R.id.result);
+        mPA2 = view.findViewById(R.id.textview_pbs);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFA_B = bundle.getDouble("ProbabilityB|A_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+
+        mPA.setText(ProbabilityOFA.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+
+
+
+        if(ProbabilityOFA < ProbabilityOFAandB   ) {
+            mfinalanswer.setText("  P(A)  must be greater or equal to P(A and B)");
+            mresult.setText(" P(A)  must be greater or equal to P(A and B)");
+
+        }
+        else{
+            mfinalanswer.setText(ProbabilityOFA_B.toString());
+            mresult.setText(ProbabilityOFA_B.toString());
+        }
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/FirstQuartileFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -24,6 +26,11 @@ public class FirstQuartileFragment extends Fragment {
    // TextView mtextviewbottomhalf;
     TextView mtextviewfirstqr;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
 
     public FirstQuartileFragment() {
         // Required empty public constructor
@@ -40,6 +47,17 @@ public class FirstQuartileFragment extends Fragment {
        // mtextviewbottomhalf =view.findViewById(R.id.textview_upperhalf);
         mtextviewfirstqr=view.findViewById(R.id.textview_thirdqr);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle =getArguments();
         Double firstquartile =bundle.getDouble("FirstQuartile_Value");
         String[] entereddata = bundle.getStringArray("Entered_Values");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/IQRFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,7 +28,10 @@ public class IQRFragment extends Fragment {
     TextView mtextviewfirstqr;
     TextView mtextviewthirdqr1;
     TextView mtextviewfirstqr1;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
 
     public IQRFragment() {
@@ -44,6 +49,17 @@ public class IQRFragment extends Fragment {
         mtextviewfirstqr = view.findViewById(R.id.textviw_firstqr);
         mtextvieworderdata=view.findViewById(R.id.textView_orderdata);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
 
 
         Bundle bundle = getArguments();

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/IndeAunionBFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class IndeAunionBFragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPA2;
+    TextView mPaandB;
+    TextView mPaandb2;
+    TextView mPB3;
+    TextView mPA3;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+
+    public IndeAunionBFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_inde_aunion_b,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPA = view.findViewById(R.id.textview_PA);
+        mfinalanswer=view.findViewById(R.id.textview_answer);
+        mresult =view.findViewById(R.id.finalanswers);
+        mPB2 = view.findViewById(R.id.textview_pb2);
+        mPA2 = view.findViewById(R.id.textview_pa2);
+        mPaandB=view.findViewById(R.id.paandbb);
+        mPaandb2 =view.findViewById(R.id.paandbs);
+        mPB3 = view.findViewById(R.id.pb3);
+        mPA3 = view.findViewById(R.id.pa3);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mfinalanswer.setText(ProbabilityOFAorB.toString());
+        mresult.setText(ProbabilityOFAorB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPaandB.setText(ProbabilityOFAandB.toString());
+        mPaandb2.setText(ProbabilityOFAandB.toString());
+        mPB3.setText(ProbabilityOFB.toString());
+        mPA3.setText(ProbabilityOFA.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/IndependantAandB.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class IndependantAandB extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPA2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+
+    public IndependantAandB(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_independant_aand_b,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PA);
+        mPA = view.findViewById(R.id.textview_PAs);
+        mfinalanswer=view.findViewById(R.id.textview_result);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+        mPA2 = view.findViewById(R.id.textview_paandb);
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mfinalanswer.setText(ProbabilityOFAandB.toString());
+        mresult.setText(ProbabilityOFAandB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/KurtosisFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,7 +28,10 @@ public class KurtosisFragment extends Fragment {
     TextView mkurtosis;
     TextView mtextviewstd;
     TextView mnofdaaset;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
 
 
@@ -47,6 +52,17 @@ public class KurtosisFragment extends Fragment {
         mtextviewstd=view.findViewById(R.id.textview_stdvalue);
         mnofdaaset=view.findViewById(R.id.textview_numberofelement);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
 
         String[] datasetValues = bundle.getStringArray("Dataset_Values") ;

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/MaximumFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -23,6 +25,11 @@ public class MaximumFragment extends Fragment {
    TextView mtextvieworderdata;
    TextView mtextviewfinalanswer;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
     public MaximumFragment() {
         // Required empty public constructor
     }
@@ -35,6 +42,17 @@ public class MaximumFragment extends Fragment {
         mtextvieworderdata=view.findViewById(R.id.textView_orderdata);
         mtextviewfinalanswer=view.findViewById(R.id.textview_finalanswer);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
         Double maximum =bundle.getDouble("Maximum_value");
         String[] entereddata = bundle.getStringArray("Entered_values");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/MeanFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -28,6 +30,11 @@ TextView ms3sofdata;
 TextView ms3nofelements;
 TextView mmeanAnswer;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
     public MeanFragment(){
     }
 
@@ -46,10 +53,22 @@ TextView mmeanAnswer;
        ms3nofelements = view.findViewById(R.id.textview_nof);
        msofdata=view.findViewById(R.id.textViewstep3nofelements);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
 
 
        Bundle bundle = getArguments();
 
+       //Returns the value associated with the given key
        Double mean = bundle.getDouble("Mean_Value");
        Double sumofdataset = bundle.getDouble("Sum_of_Dataset");
        Integer numberofelements = bundle.getInt("Number_of_Elements");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/MeanOfDistributionFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -25,7 +27,10 @@ public class MeanOfDistributionFragment extends Fragment {
     TextView mtextviewmeananswer;
     TextView msumofdisplay;
     TextView msumofdis1;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
 
     public MeanOfDistributionFragment(){
@@ -43,6 +48,17 @@ public class MeanOfDistributionFragment extends Fragment {
         mtextviewmeananswer = view.findViewById(R.id.textview_meanvalueansw);
         msumofdisplay=view.findViewById(R.id.sumofdisplay);
         msumofdis1=view.findViewById(R.id.sumofdisplay1);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
 
 
 

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/MedianFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -24,6 +26,11 @@ public class MedianFragment extends Fragment {
     TextView mtxtviewascorderdata;
     TextView mtxtviewfinalans;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
 
 
     public MedianFragment() {
@@ -40,6 +47,17 @@ public class MedianFragment extends Fragment {
         mtxtviewascorderdata=view.findViewById(R.id.txtview_ascdata);
         mtxtviewfinalans=view.findViewById(R.id.textview_finalanswer);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
         String[] entereddata = bundle.getStringArray("Entered_values");
         String data4 = Arrays.toString(entereddata);

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/MinimumFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -24,6 +26,11 @@ public class MinimumFragment extends Fragment {
         TextView mtextvieworderdata;
         TextView mtextviewfinalanswer;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
         public MinimumFragment() {
             // Required empty public constructor
         }
@@ -36,6 +43,17 @@ public class MinimumFragment extends Fragment {
             mtextvieworderdata=view.findViewById(R.id.textView_orderdata);
             mtextviewfinalanswer=view.findViewById(R.id.textview_finalanswer);
 
+            mtextView15 = view.findViewById(R.id.textView15);
+            mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+            blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+            // mtextView15.startAnimation(blink_anim);
+            mtextView16.startAnimation(blink_anim);
+
+            move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+            mtextView15.startAnimation(move_anim);
+
             Bundle bundle = getArguments();
             Double minimum =bundle.getDouble("Minimum_value");
             String[] entereddata = bundle.getStringArray("Entered_values");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ModeFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,6 +28,12 @@ public class ModeFragment extends Fragment {
     TextView mtexviewfinalanswer;
     String[] array;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
 
 
     public ModeFragment() {
@@ -42,6 +50,17 @@ public class ModeFragment extends Fragment {
         mtextviewascendingorder=view.findViewById(R.id.textView_ascedingdata);
         mtexviewfinalanswer=view.findViewById(R.id.textview_finalanswer);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
         double[] ascendingdata =bundle.getDoubleArray("Ascending_order");
         String data4 = Arrays.toString(ascendingdata);

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/PopulationStandardDeviationFragment.java

@@ -9,6 +9,8 @@ import androidx.fragment.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -23,6 +25,10 @@ public class PopulationStandardDeviationFragment extends Fragment {
     TextView mfinalanswer;
     TextView mtextviewmean;
     TextView mtextviewnumberpfele;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
 
 
@@ -42,6 +48,17 @@ public class PopulationStandardDeviationFragment extends Fragment {
         mtextviewmean =view.findViewById(R.id.textview_mean);
         mtextviewnumberpfele=view.findViewById(R.id.textview_numberofelements);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
 
         String[] datasetValues = bundle.getStringArray("Dataset_Values") ;

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/PopulationVarianceFragment.java

@@ -9,6 +9,8 @@ import androidx.fragment.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,6 +28,12 @@ public class PopulationVarianceFragment extends Fragment {
     TextView mnoofdataset;
 
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
 
 
     public PopulationVarianceFragment() {
@@ -43,7 +51,16 @@ public class PopulationVarianceFragment extends Fragment {
         mvariance=view.findViewById(R.id.textview_variancepop);
         mnoofdataset=view.findViewById(R.id.textview_numberofelement);
         //mstdvalue=view.findViewById(R.id.textview_stdvalue);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
 
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
         Bundle bundle = getArguments();
 
         String[] datasetValues = bundle.getStringArray("Dataset_Values") ;

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ProbabilityOfAForDependantEventFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class ProbabilityOfAForDependantEventFragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPAandB;
+    TextView mPAorB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPAandB2;
+    TextView mPAorB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public ProbabilityOfAForDependantEventFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_probability_of_a_for_dependant_event,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mPAorB =view.findViewById(R.id.textview_PAorB);
+        mfinalanswer=view.findViewById(R.id.textview_pa);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+        mPAandB2 = view.findViewById(R.id.textview_paandbs);
+        mPAorB2=view.findViewById(R.id.textview_paorb);
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        System.out.println("Probalility A...:"+ProbabilityOFA);
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        System.out.println("Probalility B...:"+ProbabilityOFB);
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+        System.out.println("Probalility AorB...:"+ProbabilityOFAorB);
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        System.out.println("Probalility AandB...:"+ProbabilityOFAandB);
+
+        if(ProbabilityOFAorB < ProbabilityOFB  || ProbabilityOFAandB > ProbabilityOFB  ) {
+            mfinalanswer.setText("P(A or B) must be greater or equal to P(B)");
+            mresult.setText("P(A or B) must be greater or equal to P(B)");
+
+        }
+        else {
+            mfinalanswer.setText(ProbabilityOFA.toString());
+            mresult.setText(ProbabilityOFA.toString());
+
+        }
+
+
+            mPB.setText(ProbabilityOFB.toString());
+            mPAandB.setText(ProbabilityOFAandB.toString());
+            mPAorB.setText(ProbabilityOFAorB.toString());
+            //mfinalanswer.setText(ProbabilityOFA.toString());
+           // mresult.setText(ProbabilityOFA.toString());
+            mPB2.setText(ProbabilityOFB.toString());
+            mPAandB2.setText(ProbabilityOFAandB.toString());
+            mPAorB2.setText(ProbabilityOFAorB.toString());
+
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ProbabilityOfAIndependantEvent.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class ProbabilityOfAIndependantEvent extends Fragment {
+
+
+    TextView mPB;
+    TextView mPAandB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPAandB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+    public ProbabilityOfAIndependantEvent(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_probability_of_a_independant_event,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mfinalanswer=view.findViewById(R.id.textview_pa);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPB2 = view.findViewById(R.id.textview_pbs);
+        mPAandB2 = view.findViewById(R.id.textview_paandb);
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+        if( ProbabilityOFAandB > ProbabilityOFA  ) {
+            mfinalanswer.setText(" P(A) must be greater or equal to P(A and B)");
+            mresult.setText("P(A) must be greater or equal to P(A and B)");
+
+        }
+        else{
+            mfinalanswer.setText(ProbabilityOFA.toString());
+            mresult.setText(ProbabilityOFA.toString());
+
+        }
+        mPB.setText(ProbabilityOFB.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ProbabilityOfBForDependantEventFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class ProbabilityOfBForDependantEventFragment extends Fragment {
+
+
+    TextView mPA;
+    TextView mPAandB;
+    TextView mPAorB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPA2;
+    TextView mPAandB2;
+    TextView mPAorB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+    public ProbabilityOfBForDependantEventFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_probability_of_b_for_dependant_event,container,false);
+
+
+        mPA = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mPAorB =view.findViewById(R.id.textview_PAorB);
+        mfinalanswer=view.findViewById(R.id.textview_pa);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPA2 = view.findViewById(R.id.textview_pbs);
+        mPAandB2 = view.findViewById(R.id.textview_paandbs);
+        mPAorB2=view.findViewById(R.id.textview_paorb);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+
+        if(ProbabilityOFAorB < ProbabilityOFA  || ProbabilityOFAandB > ProbabilityOFA  ) {
+            mfinalanswer.setText("P(A or B) must be greater or equal to P(A)");
+            mresult.setText("P(A or B) must be greater or equal to P(A)");
+
+        }
+        else
+        {
+            mfinalanswer.setText(ProbabilityOFB.toString());
+            mresult.setText(ProbabilityOFB.toString());
+        }
+
+
+
+        mPA.setText(ProbabilityOFA.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPAorB.setText(ProbabilityOFAorB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+        mPAorB2.setText(ProbabilityOFAorB.toString());
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ProbabilityOfBIndependantEvent.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class ProbabilityOfBIndependantEvent extends Fragment {
+
+
+    TextView mPA;
+    TextView mPAandB;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPA2;
+    TextView mPAandB2;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+    public ProbabilityOfBIndependantEvent(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_probability_of_b_independant_event,container,false);
+
+
+        mPA = view.findViewById(R.id.textview_PB);
+        mPAandB = view.findViewById(R.id.textview_PAandB);
+        mfinalanswer=view.findViewById(R.id.textview_pa);
+        mresult =view.findViewById(R.id.finalanswer);
+        mPA2 = view.findViewById(R.id.textview_pbs);
+        mPAandB2 = view.findViewById(R.id.textview_paandb);
+
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+
+
+        if( ProbabilityOFAandB > ProbabilityOFB  ) {
+            mfinalanswer.setText(" P(B) must be greater or equal to P(A and B)");
+            mresult.setText("P(B) must be greater or equal to P(A and B)");
+
+        }
+        else{
+            mfinalanswer.setText(ProbabilityOFB.toString());
+            mresult.setText(ProbabilityOFB.toString());
+        }
+        mPA.setText(ProbabilityOFA.toString());
+        mPAandB.setText(ProbabilityOFAandB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPAandB2.setText(ProbabilityOFAandB.toString());
+
+
+
+
+
+
+
+
+
+
+        mfinalanswer.setMovementMethod(new ScrollingMovementMethod());
+        mresult.setMovementMethod(new ScrollingMovementMethod());
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/RangeFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,6 +28,12 @@ public class RangeFragment extends Fragment {
     TextView mtextviewmax;
     TextView mtextviewmin;
 
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
 
     public RangeFragment() {
         // Required empty public constructor
@@ -42,6 +50,17 @@ public class RangeFragment extends Fragment {
         mtextviewmax = view.findViewById(R.id.textview_thirrdqr);
         mtextviewmin = view.findViewById(R.id.textviw_firstqr);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+       // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
         Double range = bundle.getDouble("Range_value");
         String[] entereddata = bundle.getStringArray("Entered_Values");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/SkewnessFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -26,6 +28,10 @@ public class SkewnessFragment extends Fragment {
     TextView mskewness;
     TextView mnumofele;
     TextView mnoofelements;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
 
 
@@ -47,6 +53,17 @@ public class SkewnessFragment extends Fragment {
         mnumofele=view.findViewById(R.id.textview_numberofelements);
         mnoofelements=view.findViewById(R.id.textview_numberofelement);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
         Bundle bundle = getArguments();
 
         String[] datasetValues = bundle.getStringArray("Dataset_Values") ;

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/StandardDeviationDistributionFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -24,7 +26,10 @@ public class StandardDeviationDistributionFragment extends Fragment {
     TextView mtextviewresultpx;
     TextView mtextviewstdanswer;
     TextView mtextviewmeanvalue;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
     public StandardDeviationDistributionFragment(){
     }
@@ -40,7 +45,16 @@ public class StandardDeviationDistributionFragment extends Fragment {
         mtextviewresultpx=view.findViewById(R.id.textview_resultpx);
         mtextviewstdanswer = view.findViewById(R.id.textview_stdvalueansw);
         mtextviewmeanvalue=view.findViewById(R.id.meanvalue);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
 
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
 
 
 

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/ThirdQuartileFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -23,7 +25,10 @@ public class ThirdQuartileFragment extends Fragment {
     TextView mtextviewordereddata;
    // TextView mtextviewbottomhalf;
     TextView mtextviewthirdqr;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
     public ThirdQuartileFragment() {
         // Required empty public constructor
     }
@@ -35,6 +40,18 @@ public class ThirdQuartileFragment extends Fragment {
         //mtextviewbottomhalf =view.findViewById(R.id.textview_upperhalf);
         mtextviewthirdqr=view.findViewById(R.id.textview_thirdqr);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
         Bundle bundle =getArguments();
         Double thirdquartile =bundle.getDouble("ThirdQuartile_Value");
         String[] entereddata = bundle.getStringArray("Entered_values");

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/TypeThreeIndeAUnionBFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class TypeThreeIndeAUnionBFragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPA2;
+    TextView mPA3;
+    TextView mPaandB;
+    TextView mPaandb2;
+    TextView mPaandb3;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+
+    public TypeThreeIndeAUnionBFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_type_three_inde_a_union_b,container,false);
+
+
+        mPA = view.findViewById(R.id.textview_PB);
+        mPaandB = view.findViewById(R.id.textview_PA);
+        mPB=view.findViewById(R.id.pb3);
+        mresult =view.findViewById(R.id.finalanswers);
+        mPA2 = view.findViewById(R.id.textview_pb2);
+        mPaandb2  = view.findViewById(R.id.textview_pa2);
+        mPB2 =view.findViewById(R.id.paandbs);
+        mPA3 = view.findViewById(R.id.pa3);
+        mPaandb3 = view.findViewById(R.id.paandbb);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mresult.setText(ProbabilityOFAorB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPA3.setText(ProbabilityOFA.toString());
+        mPaandB.setText(ProbabilityOFAandB.toString());
+        mPaandb2.setText(ProbabilityOFAandB.toString());
+        mPaandb3.setText(ProbabilityOFAandB.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/TypeTwoA_Union_B_IndeFragment.java

+package com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.StepsFragment;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
+import android.text.method.ScrollingMovementMethod;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.TextView;
+
+import com.elearning.probabilityandstatisticsanalyserandeducator.R;
+
+import java.util.Arrays;
+
+
+public class TypeTwoA_Union_B_IndeFragment extends Fragment {
+
+
+    TextView mPB;
+    TextView mPA;
+    TextView mfinalanswer;
+    TextView mresult;
+    TextView mPB2;
+    TextView mPA2;
+    TextView mPaandB;
+    TextView mPaandb2;
+    TextView mPB3;
+    TextView mPaandb3;
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
+
+
+
+
+    public TypeTwoA_Union_B_IndeFragment(){
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_type_two_a__union__b__inde,container,false);
+
+
+        mPB = view.findViewById(R.id.textview_PB);
+        mPaandB = view.findViewById(R.id.textview_PA);
+        mfinalanswer=view.findViewById(R.id.textview_answer);
+        mresult =view.findViewById(R.id.finalanswers);
+        mPB2 = view.findViewById(R.id.textview_pb2);
+        mPaandb2  = view.findViewById(R.id.textview_pa2);
+        mPA=view.findViewById(R.id.paandbb);
+        mPA2 =view.findViewById(R.id.paandbs);
+        mPB3 = view.findViewById(R.id.pb3);
+        mPaandb3 = view.findViewById(R.id.pa3);
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
+
+
+
+
+        Bundle bundle = getArguments();
+
+        //Returns the value associated with the given key
+        Double ProbabilityOFA = bundle.getDouble("ProbabilityA_value");
+        Double ProbabilityOFB = bundle.getDouble("ProbabilityB_value");
+        Double ProbabilityOFAandB = bundle.getDouble("ProbabilityAandB_value");
+        Double ProbabilityOFAorB = bundle.getDouble("ProbabilityAorB_value");
+
+
+        mPB.setText(ProbabilityOFB.toString());
+        mPA.setText(ProbabilityOFA.toString());
+        mfinalanswer.setText(ProbabilityOFAorB.toString());
+        mresult.setText(ProbabilityOFAorB.toString());
+        mPB2.setText(ProbabilityOFB.toString());
+        mPA2.setText(ProbabilityOFA.toString());
+        mPaandB.setText(ProbabilityOFAandB.toString());
+        mPaandb2.setText(ProbabilityOFAandB.toString());
+        mPB3.setText(ProbabilityOFB.toString());
+        mPaandb3.setText(ProbabilityOFAandB.toString());
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        return view;
+    }
+
+
+
+}
\ No newline at end of file

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/calculationfunction/StepsFragment/VarianceOfDistributionFragment.java

@@ -10,6 +10,8 @@ import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
 import android.widget.TextView;
 
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
@@ -24,7 +26,10 @@ public class VarianceOfDistributionFragment extends Fragment {
     TextView mtextviewresultpx;
     TextView mtextviewvarianceanswer;
     TextView mtextviewmeanvalue;
-
+    TextView mtextView15;
+    TextView mtextView16;
+    Animation blink_anim;
+    Animation move_anim;
 
     public VarianceOfDistributionFragment(){
     }
@@ -41,6 +46,15 @@ public class VarianceOfDistributionFragment extends Fragment {
         mtextviewvarianceanswer = view.findViewById(R.id.textview_variancevalueansw);
         mtextviewmeanvalue=view.findViewById(R.id.meanvalue);
 
+        mtextView15 = view.findViewById(R.id.textView15);
+        mtextView16 = view.findViewById(R.id.textviw_finalvue);
+
+        blink_anim = AnimationUtils.loadAnimation(getContext(),R.anim.blinkeffect);
+
+        // mtextView15.startAnimation(blink_anim);
+        mtextView16.startAnimation(blink_anim);
+        move_anim = AnimationUtils.loadAnimation(getContext(),R.anim.moveanimation);
+        mtextView15.startAnimation(move_anim);
 
 
 

app/src/main/java/com/elearning/probabilityandstatisticsanalyserandeducator/inputMethod/ProbabilityCalculationIM.java

@@ -45,6 +45,7 @@ import com.chaquo.python.android.AndroidPlatform;
 import com.elearning.probabilityandstatisticsanalyserandeducator.MainActivity;
 import com.elearning.probabilityandstatisticsanalyserandeducator.R;
 import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.DescriptiveStatisticsCalcuation;
+import com.elearning.probabilityandstatisticsanalyserandeducator.calculationfunction.ProbablilityCalculation;
 import com.elearning.probabilityandstatisticsanalyserandeducator.dataExtraction.DescriptiveStatisticsCSVfile;
 import com.elearning.probabilityandstatisticsanalyserandeducator.dataExtraction.DescriptiveStatisticsQuestionComparation;
 import com.elearning.probabilityandstatisticsanalyserandeducator.dataExtraction.ExtractData;
@@ -378,7 +379,7 @@ public class ProbabilityCalculationIM extends AppCompatActivity implements Adapt
                     // System.out.println("selected Type "+selectedRadioButton.getText().toString());
 
 
-                    Intent intent = new Intent(ProbabilityCalculationIM.this, DescriptiveStatisticsCalcuation.class);
+                    Intent intent = new Intent(ProbabilityCalculationIM.this, ProbablilityCalculation.class);
                     intent.putExtra("dataset", datasetArray);
                     intent.putExtra("des_calculation_type", selectedType);
                     intent.putExtra("PA",PA.getText().toString());

app/src/main/res/anim/blinkeffect.xml

+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <alpha
+        android:duration="600"
+        android:fromAlpha="0.0"
+        android:interpolator="@android:anim/accelerate_interpolator"
+        android:toAlpha="1.0"
+        android:repeatMode="reverse"
+        android:repeatCount="infinite"/>
+
+</set>
\ No newline at end of file

app/src/main/res/anim/moveanimation.xml

+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+        android:fillAfter="true"
+        android:interpolator="@android:anim/linear_interpolator" >
+        <translate
+            android:fromXDelta="0%p"
+            android:toXDelta="58%p"
+            android:duration="800" />
+    </set>

app/src/main/res/drawable/cardcutbackground.xml

+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+<solid android:color="#BBDEFB"/>
+    <corners
+
+
+        android:topRightRadius="500dp"/>
+</shape>
\ No newline at end of file

app/src/main/res/layout/activity_descriptive_statistics_calcuation.xml

 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
@@ -13,4 +13,4 @@
         android:id="@+id/fragment_container"/>
 
 
-   </LinearLayout>
\ No newline at end of file
+   </ScrollView>
\ No newline at end of file

app/src/main/res/layout/activity_essay_type_normal_distribution.xml

+<?xml version="1.0" encoding="utf-8"?>
+
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+
+
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:orientation="vertical"
+    android:layout_height="match_parent"
+
+    tools:context=".calculationfunction.EssayTypeNormalDistribution">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:id="@+id/LinearLayout_1">
+
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/one">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/two">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/three">
+
+
+        </FrameLayout>
+    </LinearLayout>
+
+</ScrollView>
+

app/src/main/res/layout/activity_essay_type_probability_calculation.xml

+<?xml version="1.0" encoding="utf-8"?>
+
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+
+
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:orientation="vertical"
+    android:layout_height="match_parent"
+
+    tools:context=".calculationfunction.DepEssayTypeProbabilityCalculation">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:id="@+id/LinearLayout_1">
+
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/oneLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/twoLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/threeLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/fourLayout">
+
+
+        </FrameLayout>
+
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/fiveLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/sixLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/sevenLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/eightLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/nineLayout">
+
+
+    </FrameLayout>
+    <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/tenLayout">
+
+
+    </FrameLayout>
+
+    </LinearLayout>
+
+</ScrollView>

app/src/main/res/layout/activity_indepe_essay_type_pro_calc.xml

+<?xml version="1.0" encoding="utf-8"?>
+
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+
+
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:orientation="vertical"
+    android:layout_height="match_parent"
+
+    tools:context=".calculationfunction.IndepeEssayTypeProCalc">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:id="@+id/LinearLayout_1">
+
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/sevenLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/eightLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/nineLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/tenLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/elevenLayout">
+
+
+        </FrameLayout>
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:id="@+id/tweleveLayout">
+
+
+        </FrameLayout>
+
+    </LinearLayout>
+
+</ScrollView>

app/src/main/res/layout/activity_normal_distribution_calculation.xml

+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:orientation="vertical"
+    android:layout_height="match_parent"
+    tools:context=".calculationfunction.NormalDistributionCalculation">
+
+    <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/fragment_container"/>
+
+
+</ScrollView>
\ No newline at end of file

app/src/main/res/layout/activity_probability_distribution_calculation.xml

 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
@@ -13,4 +13,4 @@
         android:id="@+id/fragment_container"/>
 
 
-</LinearLayout>
\ No newline at end of file
+</ScrollView>
\ No newline at end of file

app/src/main/res/layout/activity_probablility_calculation.xml

+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:orientation="vertical"
+    android:layout_height="match_parent"
+    tools:context=".calculationfunction.ProbablilityCalculation">
+
+    <FrameLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/fragment_container"/>
+
+
+</ScrollView>
\ No newline at end of file