Create a new version of paste:

package cryptolab1

import java.awt.BorderLayout
import java.awt.Component
import java.awt.Dimension
import java.awt.FlowLayout
import java.awt.event._
import java.io._
import java.text.DecimalFormat
import java.util.Random
import java.util.Scanner
import javax.swing._
import javax.swing.border._
import javax.swing.table._
import collection.JavaConversions._

case class E(i:Int){
  override def toString = "E"+i
}

abstract class SimplifiedModel extends AbstractTableModel{
  def getSize: (Int, Int)
  def getTitle: String
  
  def getCustomCellEditor:Map[java.lang.Class[_],TableCellEditor] = null
  def getCustomTopControl:Component = null
  
  def getColumnCount = getSize._2+1
  def getRowCount = getSize._1
}

class CryptographicFunction {
  var df = new DecimalFormat("#.##");
  var f = Array[Array[Int]]()
  var Pm,Pk = Array[Double]()
  var m,k,e:Int = 0
  var models: List[SimplifiedModel] = List()
  
  def softUpdate = models.foreach(_.fireTableDataChanged)
  def update = models.foreach(_.fireTableStructureChanged)
  
  def save(file: File){
    val prn = new PrintWriter(new FileOutputStream(file))
    prn.println(m+" "+k+" "+e)
    for (i <- 1 to k){
      for (j <- 1 to m) prn.print(f(i-1)(j-1)+" ")
      prn.println
    }
    prn.close
  }  
  
  def randomizeArray(a: Array[Double]){
    val rnd = new Random
    for (i<-0 to a.size-1) a(i) = rnd.nextDouble
    val sum = a.sum;
    for (i<-0 to a.size-1) a(i) /= sum    
  }
  
  def dumpFileScenario(prn:PrintWriter, f:File) = {
    load(f)
    prn.println("Task:;M="+m+";K="+k+";E="+e+";")
    
    randomizeArray(Pm)
    
    for (mode <- 0 to 1){
      prn.println("Keys - "+(if (mode==1) "automatic" else "same")+";")
      if (mode==1) randomizeArray(Pk);
      models.foreach(x=>{
          prn.println(x.getTitle+";")
          val l = (1 to x.getColumnCount) map {m=>x.getColumnName(m-1)}
          prn.println(l.tail.foldLeft(l.head)((a,b)=>a+";"+b)+";")
          for (i <- 1 to x.getRowCount){
            val z = (1 to x.getColumnCount) map {m=>x.getValueAt(i-1,m-1)}
            prn.println(z.tail.foldLeft(z.head)((a,b)=>a+";"+b)+";")
          }
          prn.println(";")
      })  
    }
    prn.println(";")
  }
  
  def dumpTestScenario = {
    val prn = new PrintWriter(new FileOutputStream("dump.csv"));
    List("input.txt","input_rect.txt","input_mlesse.txt").foreach({x=>dumpFileScenario(prn, new File(x))})
    prn.close
  }
  
  def load(file: File){
    val scn: Scanner = new Scanner(new FileInputStream(file))
    m = scn.nextInt
    k = scn.nextInt
    e = scn.nextInt
    
    f = (for (i <- 1 to k) yield (for (j <- 1 to m) yield scn.nextInt).toArray).toArray
    Pm = (for (i <- 1 to m) yield 1.0/m).toArray
    Pk = (for (i <- 1 to k) yield 1.0/k).toArray
    
    scn.close
    update
  }
  
  def getE = e
  def getK = k
  def getM = m
  
  def phi(m:Int, k:Int, e:Int) = if (f(k-1)(m-1)==e) 1 else 0
  
  def colF(j: Int) = for (i<-0 to k) yield f(i)(j-1)
  def Nmi(i:Int, s:Int) = colF(i-1).count(x=>x==s)
  def Pmies(i:Int, s:Int) =  (for (j<-1 to k) yield  Pk(j-1)*phi(i,j,s)).sum
  def Pes(s:Int) = (for (i<-1 to m) yield (for(j<-1 to k) yield Pk(j-1)*Pm(i-1)*phi(i,j,s)).sum).sum
  def PemMi(i:Int,s:Int) = Pm(i-1)*Pmies(i,s)/Pes(s)
  def Peskj(s:Int,j:Int) = Pk(j-1)*Pkjes(j,s)/Pes(s)
  def Pkjes(j:Int,s:Int) = (for (i<-1 to m) yield Pm(i-1)*phi(i,j,s)).sum
  def decode(k:Int, e:Int) = f(k-1).findIndexOf(x=>x==e)+1
}

class FTableModel(val crypto: CryptographicFunction) extends SimplifiedModel{
  def getSize = (crypto.getK,crypto.getM)
  
  override def getColumnName(i: Int) = if (i==0) "" else "M"+i
          
  def getValueAt(i: Int, j: Int):Object = {
    (i,j) match {
      case(v,0) => "K"+(v+1)
      case _ => E(crypto.f(i)(j-1))
    }
  }
  
  override def setValueAt(o:Object, i:Int, j:Int){
    val e = o.asInstanceOf[E]
    crypto.f(i)(j-1) = e.i
    crypto.softUpdate
  }
  
  override def isCellEditable(i: Int, j:Int) = j!=0
          
  override def getCustomCellEditor:Map[java.lang.Class[_],TableCellEditor]={
    val items = (1 to crypto.getE).map(x=>E(x))
    val comboBox = new JComboBox(asJavaList(items).toArray)
    return Map(classOf[E] -> new DefaultCellEditor(comboBox))
  } 
  
  override def getColumnClass(i:Int)= if (i==0) classOf[String] else classOf[E]
          
  def getTitle = "f(m,k)"
}

class ArraysModel(var crypto: CryptographicFunction, 
                  var title:String, var prefix:String,
                  var array:()=>Array[Double],
                  var showManual:Boolean) 
extends SimplifiedModel {
  def getSize = (array().size+1,1)
  var manualMode: JToggleButton = null;
  
  override def getColumnName(i: Int) = if (i==0) "" else title
  override def getCustomTopControl: Component={
    val panel = new JPanel
    panel.setPreferredSize(new Dimension(500,70))
    panel.setLayout(new FlowLayout(FlowLayout.LEADING, 5,2))
    val automaticButton = new JButton("Автоматично");
    automaticButton.addActionListener(new ActionListener(){
        def actionPerformed(event:ActionEvent)={
          val rnd = new Random
          for (i <- 0 to array().size-1) array()(i) = rnd.nextDouble
          val sum = array().sum
          for (i <- 0 to array().size-1) array()(i) /= sum
          crypto.softUpdate
        }
      })
    panel.add(automaticButton)

    val sameButton = new JButton("Рівномірно");
    sameButton.addActionListener(new ActionListener(){
        def actionPerformed(event:ActionEvent)={
          for (i <- 0 to array().size-1) array()(i) = 1.0/array().size
          crypto.softUpdate
        }
      })
    panel.add(sameButton)

    manualMode = new JToggleButton("Режим ЗКК")
    if (showManual)
      panel.add(manualMode)
    
    panel.setBorder(new TitledBorder("Заповення"));
    return panel
  }
  
  def getValueAt(i: Int, j: Int):Object = {
    (i,j) match {
      case(v,0) => if (v<array().size) prefix+(v+1) else "Sum"
      case _ => Double.box(if (i<array().size) array()(i) else array().sum)
    }
  }
  
  override def setValueAt(o:Object, i:Int, j:Int){
    val d = o.asInstanceOf[String].toDouble
    array()(i) = d
    if (manualMode.isSelected){
      val countNonZero = array().count(x=>x!=0.0)
      if (countNonZero>0){
          for (i <- 0 to array().size-1 if (array()(i)!=0.0)) array()(i) = 1.0/countNonZero     
      }
    }
    crypto.softUpdate
  }
  
  override def isCellEditable(i: Int, j:Int) = (j!=0) && (i<array().size)
          
  def getTitle = title   
}

class AposteriroriMessages(val crypto: CryptographicFunction) extends SimplifiedModel{
  def getSize = (crypto.getE,crypto.getM)
  
  override def getColumnName(i: Int) = if (i==0) "" else "M"+i
          
  def getValueAt(i: Int, j: Int):Object = {
    (i,j) match {
      case(v,0) => "E"+(v+1)
      case _ => crypto.df.format(crypto.PemMi(j,i+1))
    }
  }

  def getTitle = "Pe(m)"
}

class AposteriroriDifference(val crypto: CryptographicFunction) extends SimplifiedModel{
  def getSize = (crypto.getE,crypto.getM)
  
  override def getColumnName(i: Int) = if (i==0) "" else "M"+i
          
  def getValueAt(i: Int, j: Int):Object = {
    (i,j) match {
      case(v,0) => "E"+(v+1)
      case _ => crypto.df.format(crypto.PemMi(j,i+1)-crypto.Pm(j-1))
    }
  }

  def getTitle = "Pe(m)-P(m)"
}

class AposteriroriRatio(val crypto: CryptographicFunction) extends SimplifiedModel{
  def getSize = (crypto.getK,crypto.getE)
  
  override def getColumnName(i: Int) = if (i==0) "" else "E"+i
          
  def getValueAt(i: Int, j: Int):Object = {
    (i,j) match {
      case(v,0) => "K"+(v+1)
      case _ => {
          val m = crypto.decode(i+1,j)-1;
          if (m== -1) "" else {
            val cnt = (for (i<-0 to crypto.getK-1) yield crypto.f(i)(m)).count({l=>l==j})
            crypto.df.format((crypto.Pkjes(i+1,j)/crypto.Pm(m)/cnt))
          }
      }
    }
  }

  def getTitle = "Pe(k)/P(m)"
}

class GUIBuilder(val crypto: CryptographicFunction){
  var frame: JFrame = null
          
  def build {
    val tabs = crypto.models
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName)
            
    frame = new JFrame;
    frame.setSize(600, 500)
    frame.setTitle("Криптографія")
    frame.setLayout(new BorderLayout())
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
    val tabbedPane = new JTabbedPane
    for (val tab <- tabs){
      val panel = new JPanel
      panel.setLayout(new BorderLayout())
       
      val scrollPane = new JScrollPane
      val table = new JTable
      table.setModel(tab)
      table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF)
      if (tab.getCustomCellEditor!=null)
        for (i <- tab.getCustomCellEditor){
          table.setDefaultEditor(i._1, i._2)
        }
      scrollPane.setViewportView(table)
      if (tab.getCustomTopControl!=null)
        panel.add(tab.getCustomTopControl, BorderLayout.NORTH)
      panel.add(scrollPane, BorderLayout.CENTER)
      tabbedPane.addTab(tab.getTitle, panel)
    }
    frame.add(tabbedPane)
     
    val mainMenu = new JMenuBar
    val fileMenu = new JMenu("Файл")
    val openMenuItem = new JMenuItem("Відкрити")
    val saveMenuItem = new JMenuItem("Зберегти")
    val fileChooser = new JFileChooser
    mainMenu.add(fileMenu)
    fileMenu.add(openMenuItem)
    fileMenu.add(saveMenuItem)
    openMenuItem.addActionListener(new ActionListener(){
        def actionPerformed(event:ActionEvent)={
          if (fileChooser.showOpenDialog(frame)==JFileChooser.APPROVE_OPTION){
            crypto.load(fileChooser.getSelectedFile)
          }
        }    
      })
    saveMenuItem.addActionListener(new ActionListener(){
        def actionPerformed(event:ActionEvent)={
          if (fileChooser.showSaveDialog(frame)==JFileChooser.APPROVE_OPTION){
            crypto.save(fileChooser.getSelectedFile)
          }
        }    
      })
    frame.setJMenuBar(mainMenu)
    frame.setVisible(true)
  }
}
       
object Main {

  def main(args: Array[String]): Unit = {
    val crypto = new CryptographicFunction()
    crypto.load(new File("input.txt"))
    crypto.models = List(
      new FTableModel(crypto),
      new ArraysModel(crypto, "P(mi)","M", {()=>crypto.Pm}, false),
      new ArraysModel(crypto, "P(ki)","K", {()=>crypto.Pk}, true),
      new AposteriroriMessages(crypto),
      new AposteriroriDifference(crypto),
      new AposteriroriRatio(crypto)
    )
    crypto.dumpTestScenario;
    crypto.load(new File("input.txt"))
    new GUIBuilder(crypto).build
  }

}