API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 4th, 2016
52
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 21.13 KB | None | 0 0
raw download clone embed print report
  1. package tubular;
  2.  
  3. import java.awt.Container;
  4. import java.io.BufferedReader;
  5. import java.io.FileInputStream;
  6. import java.io.FileReader;
  7. import java.io.InputStreamReader;
  8. import java.io.PrintWriter;
  9. import java.lang.Math;
  10. import java.util.Arrays;
  11. import java.util.Scanner;
  12.  
  13. public class tabular {
  14.    static String steps[]=new String[1000000];
  15.     int count=0;
  16.     String [] allSteps = new String[100000];
  17.     int indexOfArr = 0;
  18.     String alternatriveArr[];
  19.     String essentialPrime = "";
  20.     int indexOfEssentialPrime [];
  21.     static String[] binn ;
  22.     int onlyOneArray[];
  23.     String [] strOfMaxCoverages = new String[100000];
  24.     int[] arrOfMaxCoverages = new int[100000];
  25.     int indexx = 0;
  26.     int ref = 0;
  27.     static String[] finum ;
  28.     static String[] finum2 ;
  29.     static String[] pprime=new String[100000];
  30.     static String[] fprimenum=new String[100000];
  31.     String[] prime = new String[1000];
  32.    
  33.  
  34.     private boolean checkValidInput(String expression , int inputt){
  35.         String express = expression.replaceAll("\\s+", " ").trim();
  36.         String [] ex = express.split(" ");
  37.         int [] exInInteegerForm = new int[ex.length];
  38.         // test anyterm is smaller than or equal to maxterm
  39.         double maxTerm = Math.pow(2, (double)inputt) - 1;
  40.         for(int i =0 ;i<ex.length;i++){
  41.             exInInteegerForm[i] = Integer.parseInt(ex[i]);
  42.             if(exInInteegerForm[i] > maxTerm){
  43.                 return false;
  44.             }
  45.         }
  46.         // to check any invalid chars except digits
  47.         String expressWithoutSpaces = express.replace(" ", "");
  48.         for(int j=0 ;j<expressWithoutSpaces.length() ;j++){
  49.             char x = expressWithoutSpaces.charAt(j);
  50.             if(!Character.isDigit(x)){
  51.                 return false;
  52.             }
  53.         }
  54.         // for repeted number
  55.         for(int k=0 ;k<ex.length;k++){
  56.             for(int j = k+1 ;j<ex.length;j++){
  57.                 if(ex[k].equals(ex[j])){
  58.                     return false;
  59.                 }
  60.             }
  61.         }
  62.         return true;
  63.     }
  64.    
  65.     private void initalize (String []arr){
  66.         alternatriveArr = new String[arr.length];
  67.         System.arraycopy(arr, 0, alternatriveArr ,0, arr.length);
  68.         onlyOneArray  = new int[binn.length];
  69.         Arrays.fill(onlyOneArray , -1);
  70.         indexOfEssentialPrime = new int[arr.length];
  71.         Arrays.fill(indexOfEssentialPrime , -1);
  72.         Arrays.fill(arrOfMaxCoverages, -1);
  73.     }
  74.    
  75.  // parameter is string representing minterms of each term
  76.     private int[] checkOnlyOne (String[] arr){
  77.         int i ;
  78.         for(i =0 ;i<binn.length ;i++){
  79.             int onlyOne = 0;
  80.             int indexOfminTermMustToken = 0;
  81.             boolean exist = false;
  82.             for(int j =0  ;j<arr.length; j++){
  83.                 arr[j]=" "+arr[j]+" ";
  84.                 String a = " "+binn[i]+" ";
  85.                 if(arr[j].contains(a)){
  86.                     onlyOne++;
  87.                     indexOfminTermMustToken = j;
  88.                 }
  89.                 arr[j]=arr[j].trim();
  90.             }
  91.             // onlyOneArray contains numbers of minterms must be token
  92.             if(onlyOne == 1){
  93.                 // remove repeted onlyOneArray
  94.                 for(int k =0 ;k< onlyOneArray.length;k++){
  95.                     if(onlyOneArray[k]==indexOfminTermMustToken){
  96.                         exist= true;
  97.                         break;
  98.                     }
  99.                 }
  100.                 if(!exist){
  101.                     indexOfEssentialPrime[indexOfArr] = indexOfminTermMustToken;
  102.                     indexOfArr++;
  103.                     onlyOneArray[i]= indexOfminTermMustToken;
  104.                     removeTokenMinTermsFormStringArr(arr[indexOfminTermMustToken]);
  105.                     break;
  106.                 }        
  107.             }
  108.         }
  109.         if(i<binn.length)
  110.             checkOnlyOne(alternatriveArr);
  111.         return onlyOneArray;
  112.     }
  113.    
  114.     private void removeTokenMinTermsFormStringArr(String token){
  115.         token = token.trim();
  116.         token = token.replaceAll("\\s+", " ");
  117.         String [] tokenn = token.split(" ");
  118.         for(int k =0 ;k<alternatriveArr.length ;k++){
  119.             alternatriveArr[k] = " " + alternatriveArr[k] +" ";
  120.             for(int i=0;i<tokenn.length;i++){
  121.                 if(tokenn[i]!=" "){
  122.                     alternatriveArr[k] = alternatriveArr[k].replace(" "+tokenn[i]+ " "," ");
  123.                 }
  124.             }
  125.             alternatriveArr[k] = alternatriveArr[k].replaceAll("\\s+", " ").trim();
  126.         }
  127.     }
  128.    
  129.     private boolean IsAlternativeEmpty(String []arr){
  130.         String term = "";
  131.         boolean empty=true;
  132.         for(int i =0 ;i<arr.length; i++){
  133.             term = arr[i].trim();
  134.             term = arr[i].replaceAll("( )+", "$1");
  135.             if(!term.equals("")){
  136.                 empty=false;
  137.                 break;
  138.             }
  139.         }
  140.         if(empty){
  141.             return true;
  142.         }
  143.         else{
  144.             return false;
  145.         }
  146.     }
  147.    
  148.     private int findEssentialPrimeImplicants(String[] arr){
  149.         if(IsAlternativeEmpty(arr)){
  150.             return 0;
  151.         }
  152.         checkOnlyOne(arr);
  153.         int maxnoOfCoverages = 0;
  154.         int indexOfmaxnoOfCoverages = -1;
  155.         int indexOfmaxnoOfCoverages2 = -1;
  156.         boolean a =false;
  157.         for(int i =0 ;i<arr.length;i++){
  158.             int noOfcoverages = alternatriveArr[i].split(" ").length;
  159.             if(alternatriveArr[i].equals("")){
  160.                 noOfcoverages = 0;
  161.             }
  162.             if(maxnoOfCoverages < noOfcoverages){
  163.                 maxnoOfCoverages = noOfcoverages;
  164.                 indexOfmaxnoOfCoverages = i;
  165.                 a= true;
  166.             }
  167.         }
  168.         if(a){
  169.             indexOfEssentialPrime[indexOfArr]=indexOfmaxnoOfCoverages;
  170.             indexOfArr++;
  171.             removeTokenMinTermsFormStringArr(alternatriveArr[indexOfmaxnoOfCoverages]);
  172.             essentialPrime += indexOfmaxnoOfCoverages;
  173.             int totalCoverage = maxnoOfCoverages+ findEssentialPrimeImplicants(alternatriveArr);  
  174.         }
  175.         return 0;
  176.     }
  177.    
  178.     private String[] removeDonotCare (String[] uncorrecttStr , String donotcare){
  179.         String[] correctStr = new String[uncorrecttStr.length];
  180.         String[] donotcareParts = donotcare.replaceAll("\\s+", " ").trim().split(" ");
  181.         Arrays.fill(correctStr, "");
  182.         for(int i=0;i<uncorrecttStr.length ;i++ ){
  183.             String [] part = uncorrecttStr[i].replaceAll("\\s+", " ").trim().split(" ");
  184.             for(int j=0 ;j<donotcareParts.length ;j++){
  185.                 for(int k=0 ;k<part.length ;k++){
  186.                     if(part[k].equals(donotcareParts[j])){
  187.                         part[k] = "";
  188.                     }
  189.                 }
  190.             }
  191.             for(int j = 0 ; j<part.length ; j++){
  192.                 correctStr[i]+= part[j] + " ";
  193.             }
  194.             correctStr[i] = correctStr[i].replaceAll("\\s+", " ").trim();
  195.         }
  196.         return correctStr;
  197.     }
  198.    
  199.     private String[] printEssentialImplicants(String[] binx){
  200.         // generates inputs
  201.         String[] printedForms = new String [binx.length];
  202.         Arrays.fill(printedForms, "");
  203.         for(int j = 0 ;j<indexOfArr ; j++){
  204.             String current = binx[indexOfEssentialPrime[j]];
  205.             for(int k=0 ;k< current.length();k++){
  206.                 if(current.charAt(k) == '0'){
  207.                     printedForms[j]+= Character.toChars(65+k)[0] + "'";
  208.                 }
  209.                 else if(current.charAt(k) == '1'){
  210.                     printedForms[j]+= Character.toChars(65+k)[0];
  211.                 }
  212.                 else if (current.charAt(k) == '-'){
  213.                 }
  214.             }
  215.         }
  216.         return printedForms;
  217.     }
  218.  
  219.     public String[] min(String minterm, int input) {
  220.         String bin[] = minterm.split(" ");
  221.         pprime=bin;
  222.        int  num[]= new int[bin.length];
  223.         String str[] = new String[bin.length];
  224.         for (int i = 0; i < bin.length; i++) {
  225.             num[i] = Integer.parseInt(bin[i]);
  226.             str[i] = new String();
  227.             str[i] = convertBinary(num[i]);
  228.             int numberOfDigit = input - str[i].length();
  229.             for (int j = 0; j < numberOfDigit; j++)
  230.                 str[i] = "0" + str[i];
  231.         }
  232.         return str;
  233.  
  234.     }
  235.  
  236.     public String convertBinary(int num) {
  237.         StringBuilder binary = new StringBuilder();
  238.         while (num > 0) {
  239.             binary.append(num % 2);
  240.             num = num / 2;
  241.         }
  242.         binary.reverse();
  243.         return binary.toString();
  244.     }
  245.  
  246.    
  247.     boolean flag=true;
  248.     public String[] rec(String org[], int input, String [] bprime) {
  249.         int k = 0;
  250.         boolean[] check = new boolean[org.length];
  251.         String[] res = new String[100];
  252.         String[] primenum=new String[20];
  253.         String temp = new String();
  254.         for (int i = org.length - 1; i >= 0; i--) {
  255.             for (int j = i - 1; j >= 0; j--) {
  256.                 temp += Math.abs(Integer.parseInt(org[i]) - Integer.parseInt(org[j]));
  257.                 int numberOfDigit = Math.abs(input - temp.length());
  258.                 for (int h = 0; h < numberOfDigit; h++)
  259.                     temp = "0" + temp;
  260.                 if (temp.length() - temp.replace("1", "").length() == 1
  261.                         && temp.length() - temp.replace("0", "").length() == input - 1) {
  262.                     check[i] = true;
  263.                     check[j] = true;
  264.                     res[k] = new String();
  265.                     int indexx = temp.indexOf("1");
  266.                     primenum[k]=new String();
  267.                     primenum[k] = bprime[i]+" "+bprime[j];
  268.                     res[k] = org[i];
  269.                     res[k] = res[k].substring(0, indexx) + '5' + res[k].substring((indexx + 1));
  270.                     //if (k!=0&&!res[k].equals(org[k-1]))
  271.                     //System.out.println(res[k].replace('5', '-')+"<--->"+primenum[k]);
  272.                     k++;
  273.                 }
  274.                 temp = new String();
  275.             }
  276.         }
  277.         for (int y = 0; y < org.length; y++) {
  278.             if (!check[y]) {
  279.                 fprimenum[ref]=bprime[y];
  280.                 prime[ref] = new String();
  281.                 prime[ref] = org[y];
  282.                 ref++;
  283.             }
  284.         }
  285.         int c = 2713;
  286.         String symbol =  "\\u" + c;
  287.         String s = Character.toString((char)c);
  288.         for (int h=0;h<org.length;h++){
  289.             if ((h==0||!org[h].equals(org[h-1]))&&!check[h]){
  290.                
  291.             steps[count]=new String();
  292.             steps[count]=org[h].replace('5', '-')+" == > "+bprime[h]+" == > Prime!!";
  293.             count++;
  294.             }
  295.             else if ((h==0||!org[h].equals(org[h-1]))&&check[h]){
  296.                 steps[count]=new String();
  297.  
  298.                 steps[count]=org[h].replace('5', '-')+" == > "+bprime[h]+" == > X";
  299.                 count++;
  300.             }
  301.         }
  302.         steps[count]=new String();
  303.         steps[count]="---------------Next Step---------------";
  304.         count++;
  305.         String[] resanum = new String[k];
  306.         String[] resa = new String[k];
  307.         for (int l = 0; l < k; l++)
  308.             {
  309.             resanum[l]=primenum[l];
  310.             resa[l] = res[l];
  311.            
  312.             }
  313.    
  314.         if (allfalse(check)) {
  315.             String[] fiprime = new String[ref];
  316.             finum = new String[ref];
  317.             for (int i = 0; i < ref; i++) {
  318.                 fiprime[i] = new String();
  319.                 finum[i]=new String();
  320.                 finum[i]=fprimenum[i];
  321.                 fiprime[i] = prime[i];
  322.                 fiprime[i] = fiprime[i].replace('5', '-');
  323.             }
  324.            
  325.             fiprime = removeDuplicates(fiprime);
  326.             return fiprime;
  327.         }
  328.  
  329.         else
  330.  
  331.             return rec(resa, input,primenum);
  332.  
  333.     }  
  334.     private static boolean allfalse(boolean[] values) {
  335.         for (boolean value : values) {
  336.             if (value)
  337.                 return false;
  338.         }
  339.         return true;
  340.     }
  341.  
  342.     public static String[] removeDuplicates(String[] arr) {
  343.  
  344.         int end = arr.length;
  345.  
  346.         for (int i = 0; i < end; i++) {
  347.             for (int j = i + 1; j < end; j++) {
  348.                 if (arr[i].equals(arr[j])) {
  349.                     int shiftLeft = j;
  350.                     for (int k = j + 1; k < end; k++, shiftLeft++) {
  351.                         arr[shiftLeft] = arr[k];
  352.                         finum[shiftLeft]=finum[k];
  353.                     }
  354.                     end--;
  355.                     j--;
  356.                 }
  357.             }
  358.         }
  359.         finum2 = new String[end];
  360.         String[] whitelist = new String[end];
  361.         for (int i = 0; i < end; i++) {
  362.             finum2[i] = finum[i];
  363.             whitelist[i] = arr[i];
  364.         }
  365.         return whitelist;
  366.     }
  367.  
  368.     public static void main(String[] args) {
  369.        
  370. //        binn = "0 1 4 8 10 12 20 23 28 30 32 35 39 44 45 49 51 56 58 61 63 71 73 76 81 85 86 88 91 93 95 96 101 103 105 111 118 121 127".split(" ");
  371.        
  372.         while(true){
  373.         boolean valid = false;
  374.         System.out.println("Enter file to scan from file or any key to scan from console");
  375.         Scanner inputt = new Scanner(System.in);
  376.         String choose = inputt.nextLine();
  377.         String [] temp = new String[10];
  378.         int counter =0 ;
  379.         if(choose.equals("file")){
  380.             tabular test = new tabular();
  381.             String inputNumberss ;
  382.             BufferedReader buffer = null;  
  383.             String path;
  384.             String outputPath;
  385.             try{
  386.                 System.out.println("Enter Path");
  387.                 path = inputt.nextLine().replace("\\", "/");
  388.                 System.out.println("Enter output Path");
  389.                 outputPath = inputt.nextLine().replace("\\", "/");
  390.                 FileInputStream ss = new FileInputStream(path);
  391.                 buffer = new BufferedReader(new InputStreamReader(ss));
  392.                 while((temp[counter] = buffer.readLine()) != null){
  393.                     counter++;
  394.                 }
  395.                
  396.                 String minTerms = "";
  397.                 String donotcareTerms="";
  398.                 int inputNumbers=-1;
  399.                
  400.                 try{
  401.                 inputNumberss = temp[0];
  402.                 inputNumberss = inputNumberss.replaceAll("\\s+", " ").trim();
  403.                 inputNumbers = Integer.parseInt(inputNumberss);
  404.                 minTerms = temp[1];
  405.                 donotcareTerms = temp[2];
  406.                 minTerms = minTerms.replaceAll("\\s+", " ").trim();
  407.                 donotcareTerms = donotcareTerms.replaceAll("\\s+", " ").trim();
  408.                 try{
  409.                     valid = test.checkValidInput((minTerms+ " " +donotcareTerms).replaceAll("\\s+", " ").trim(), inputNumbers);
  410.                 }
  411.                 catch(NumberFormatException e){
  412.                     valid = false;
  413.                     if(minTerms.replaceAll("\\s+", " ").trim().equals("")&& donotcareTerms.replaceAll("\\s+", " ").trim().equals("")){
  414.                         System.out.println("1");
  415.                         System.out.println("");
  416.                         continue;
  417.                     }
  418.                 }
  419.                 }
  420.                 catch(NumberFormatException e){
  421.                     valid = false;
  422.                 }
  423.                 if(valid){
  424.                     String [] a = test.min((minTerms+ " " +donotcareTerms).replaceAll("\\s+", " ").trim(), inputNumbers);
  425.                     String [] b = test.rec(a, inputNumbers, pprime);
  426.                     String d [] = test.removeDonotCare(finum2,donotcareTerms);
  427.                     binn =( minTerms + " " + donotcareTerms ).replaceAll("\\s+", " ").trim().split(" ");
  428.                     test.initalize(d);
  429.                     PrintWriter writer = new PrintWriter(outputPath);
  430.                     for (int i = 0; (steps[i]!= null) &&(i < steps.length); i++) {
  431.                         writer.println(steps[i]);
  432.                     }
  433.                    
  434.                  /*   for (int i = 0; i < finum2.length; i++) {
  435.                         writer.println(b[i]+" ==> "+finum2[i]);
  436.                     }*/
  437.                     if(minTerms.replaceAll("\\s+", " ").trim().equals("")){
  438.                         writer.println("");
  439.                         writer.println("final result == > 0");
  440.                         writer.close();
  441.                     }
  442.                     else if(minTerms.replaceAll("\\s+", " ").trim().split(" ").length == Math.pow(2, (double)inputNumbers)){
  443.                         writer.println("");
  444.                         writer.println("final result == > 1");
  445.                         writer.close();
  446.                     }
  447.                     else  {
  448.                         int n = test.findEssentialPrimeImplicants(d);
  449.                         String c [] = test.printEssentialImplicants(b);
  450.                         String total = "";
  451.                         for (int i = 0; i < c.length; i++) {
  452.                             total += c[i] ;
  453.                             if(i!=c.length-1){
  454.                                 total+="+";
  455.                             }
  456.                         }
  457.                         String dd=total;
  458.                         int count2=total.length()-1;
  459.                         while(dd.charAt(count2)=='+'){
  460.                           dd=dd.substring(0,count2);
  461.                           count2--;
  462.  
  463.                         }  
  464.                         /*
  465.                         for (int i = 0; i < finum2.length; i++) {
  466.                             writer.println(b[i]+" ==> "+finum2[i]);
  467.                         } */
  468.                         writer.println(dd);
  469.                         writer.close();
  470.                     }
  471.                  }
  472.                     else{
  473.                         System.out.println("Error .. try again");
  474.                         continue;
  475.                     }
  476.                
  477.             }
  478.             catch(Exception e){
  479.                 System.out.println("invalid path");
  480.             }
  481.             continue;
  482.         }
  483.         else{
  484.        
  485.         String minTerms = "";
  486.         String donotcareTerms="";
  487.         int inputNumbers=-1;
  488.         tabular test = new tabular();
  489.        
  490.         try{
  491.         System.out.println("Please Enter no of input varibles");
  492.         String inputNumberss = inputt.nextLine();
  493.         inputNumberss = inputNumberss.replaceAll("\\s+", " ").trim();
  494.         inputNumbers = Integer.parseInt(inputNumberss);
  495.         System.out.println("Please Enter Min terms separetd by spaces");
  496.         minTerms = inputt.nextLine();
  497.         System.out.println("Please Enter don't care terms separetd by spaces if no don't care click space");
  498.         donotcareTerms = inputt.nextLine();
  499.         System.out.println("");
  500.         minTerms = minTerms.replaceAll("\\s+", " ").trim();
  501.         donotcareTerms = donotcareTerms.replaceAll("\\s+", " ").trim();
  502.         try{
  503.             valid = test.checkValidInput((minTerms+ " " +donotcareTerms).replaceAll("\\s+", " ").trim(), inputNumbers);
  504.         }
  505.         catch(NumberFormatException e){
  506.             valid = false;
  507.             if(minTerms.replaceAll("\\s+", " ").trim().equals("")&& donotcareTerms.replaceAll("\\s+", " ").trim().equals("")){
  508.                 System.out.println("1");
  509.                 System.out.println("");
  510.                 continue;
  511.             }
  512.         }
  513.         }
  514.         catch(NumberFormatException e){
  515.             valid = false;
  516.         }
  517.         if(valid){
  518.             String [] a = test.min((minTerms+ " " +donotcareTerms).replaceAll("\\s+", " ").trim(), inputNumbers);
  519.             String [] b = test.rec(a, inputNumbers, pprime);
  520.            
  521.             for (int i = 0;(steps[i]!= null) && (i < steps.length) ; i++) {
  522.                 System.out.println(steps[i]);
  523.             }
  524.             System.out.println("");
  525.             String d [] = test.removeDonotCare(finum2,donotcareTerms);
  526.             binn =( minTerms + " " + donotcareTerms ).replaceAll("\\s+", " ").trim().split(" ");
  527.             test.initalize(d);
  528.             if(minTerms.replaceAll("\\s+", " ").trim().equals("")){
  529.                 System.out.println("0");
  530.             }
  531.             else if(minTerms.replaceAll("\\s+", " ").trim().split(" ").length == Math.pow(2, (double)inputNumbers)){
  532.                 System.out.println("1");
  533.             }
  534.             else  {
  535.                 int n = test.findEssentialPrimeImplicants(d);
  536.                 String c [] = test.printEssentialImplicants(b);
  537.                 String total = "";
  538.                 for (int i = 0; i < c.length; i++) {
  539.                     total += c[i] ;
  540.                     if(i!=c.length-1){
  541.                         total+="+";
  542.                     }
  543.                 }
  544.                 String dd=total;
  545.                 int count2=total.length()-1;
  546.                 while(dd.charAt(count2)=='+'){
  547.                   dd=dd.substring(0,count2);
  548.                   count2--;
  549.  
  550.                 }
  551.                 System.out.println(dd);
  552.  
  553.             }
  554.          }
  555.             else{
  556.                 System.out.println("Error .. try again");
  557.                 continue;
  558.             }
  559.         }
  560.        }
  561.    }
  562. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!