class Vektor(val koord: List[Double]) {
  def +(a: Vektor) = { // Vektoraddition
    val v = angleichen(a)
    new Vektor (for{(x,y) <- v._1.koord zip v._2.koord} yield x+y)
  }
  
  def -(a: Vektor) = { // Vektorsubtraktion
    val v = angleichen(a)
    new Vektor (for{(x,y) <- v._1.koord zip v._2.koord} yield x-y)
  }  
  def unary_- = { // Unärer Minusoperator -this
    new Vektor (for{x <- koord} yield -x)
  }
  
  def *(a: Double) = { // Skalarmultiplikation (Aufruf: Vektor*a)
    new Vektor (for{x <- koord} yield a*x)
  }
  
  def *(a: Vektor) = { // Vektorprodukt
    val v = angleichen(a)
    var c = 0.0
    for{(x,y) <- v._1.koord zip v._2.koord} yield c = c + x*y; c
  }

  override def toString = koord.toString() replace("List", "")

  /** gleicht Dimension der Vektore p und this an. */
  private def angleichen(p: Vektor): (Vektor, Vektor) = {
    if (koord.size == p.koord.size) {
      (this, p)
    } else if (koord.size > p.koord.size) {
      (this, new Vektor(pad(p.koord, koord.size - p.koord.size, 0.)))
    } else {
      (new Vektor(pad(koord, p.koord.size - koord.size, 0.)), p)
    }
  }
  
  /** Füllt die Liste list mit n Einträgen x auf. */
  private def pad(list: List[Double], n: Int, x: Double): List[Double] = {
    if (n == 1) list :+ x else list ::: pad(list, n-1, x)
  }
}

object Vektor {  // Begleitobjekt
  def apply(x: Double*) = new Vektor(x.toList)
}

class WrappedDouble(val a: Double) {
  def *(v: Vektor): Vektor = v*a
}

object VektorTest extends Application {
  implicit def wrapDouble(a: Double) = new WrappedDouble(a)
  val v = Vektor(1, 2, 3)
  val w = Vektor(-1, 1)
  println((v+w)+", "+(v-w)+", "+2*v+", "+v*w) // => (0,3,3), (2,1,3), (2,4,6), 1
  //v.angleichen(w)                           // => Fehlermeldung, da private!
}