valtih1978

object generator {

	// Coursera Reactive programming
		
	trait Generator[T] { self =>
		def generate: T
		def map[K](f: T => K) = new Generator[K] {
//			{val sample = generate ; println("map creates a generator [" + sample.getClass().getSimpleName + "]") }
			def generate: K = f(self.generate)
		}

valtih1978

// This talk https://www.youtube.com/watch?v=MGfr_col5PI claims that if 4% of healty people degenerate with every 
// and if 50% recover from defective genetics then we reach 8% failed genetics. Here is the simulation that confirms this.

	def sim1(healthy: Double, generation: Int = 1): Unit = if (generation < 100) {
		val degenerates = 1 - healthy; println((degenerates * 100) + "% down" )
		sim1(healthy * 0.96 + degenerates * 0.5, generation + 1)
	}                                         //> sim1: (healthy: Double, generation: Int)Unit
	
	sim1(1)                                   //> 0.0% down
                                                  //| 4.0000000000000036% down

valtih1978

	trait E {
		def e(dict: Map[Const, Int]): Int
		def +(another: E): E = (this, another) match {
			case (zero, _) => another // Bug! Bug! this unintentionally redefines zero
			case (_, zero) => this
			case _ => Plus(this, another)
		}
		def *(another: E): E = {
			def par(e: E) = e match {case e @ Plus(a,b) => Par(e); case e => e}
			Mult(par(this), par(another))

valtih1978

import Vhdl._

// TODO: CharLiteral -> Char, StringLiteral -> String to save memory

object AllTests extends App {
  def recover[T](okMsg: String/*, shouldRecover: T => Boolean = _ => true*/): ParseResult[T] => ParseResult[_] = pr => pr match {
    case f @ Failure(msg, rem) => Success(okMsg, rem) //if (shouldRecover(msg)) Success(okMsg, rem) else f
    case e @ Error(msg, rem) => println("Recovering error " + msg); Success(okMsg, rem) //if (shouldRecover(msg)) Success(okMsg, rem) else f
    case s @ Success(msg, rem) => Failure(s"we had to fail because $okMsg but succeeded with " + msg, rem); case a => a
  }

valtih1978

import java.lang.reflect.{Method, InvocationHandler, Proxy}		
import scala.language.reflectiveCalls, scala.language.postfixOps		
import scala.collection.mutable, java.io._, Util._

// I called this version "reduced" because proxies are not GC-ed when not referenced by user
// This makes a code a bit simpler and, probably, even faster if proxies are small indeed. 
// The experiment 
	// timeit "scala -J-Xmx33m ProxyDemo + 16 100 > nul" 
// however suggests that this implementation is slow as 144 sec vs 129 sec for managed proxies.

valtih1978

const log = console.log ; const assert = console.assert
//Object.prototype.trace = function(format) {format = format || (data => data); log(format(this)); return this} // prints something wrong
const trace = (data, format) => {format = format || (data => data); log(format(data)); return data}
const tracejs = (ms, data) => trace(data, data => [ms, data.json()])
function range (len, begin) {begin = begin || 0
  return Array.apply(null, Array(len)).map((_, i) => {return begin+i;})}
//Array.prototype.fill = function(filler) {return this.map(_ => filler)} // startard func
Array.prototype.equals = function(that) {return this.every((my, i) => my == that[i] )} ; [1,2].equals([1,2])

Array.prototype.sum = function() {return this.reduce((acc, el) => acc + el,0)}

valtih1978

<script id="library" title="it must be a part of starndard javascript">
  const log = console.log ; const assert = console.assert

update = (o, mutator) => {mutator(o); return o}
trace = (value, format) => {format = format || (data => data) ; log(format(value)); return value};
  tracejs = (msg, data) => trace(data, data => [msg, data.json()])

Object.prototype.trace = function(format) {trace(this, format)}

function range (len, begin) {begin = begin || 0

valtih1978

// task and parallel definition can be found at https://www.coursera.org/learn/parprog1/discussions/weeks/1/threads/2gsI2DHVEeaKAhJC1hWxEQ/replies/-avxXTIBEeabvwrOSKMg4w/comments/O5yTH3K6EeeM7BK4-ybiDA

/** Computes the blurred RGBA value of a single pixel of the input image. */
  def boxBlurKernel(src: Img, x: Int, y: Int, radius: Int): RGBA = {
    val xMin = clamp(x-radius, 0, src.width-1)
    val xMax = clamp(x+radius, 0, src.width-1)
    val yMin = clamp(y-radius, 0, src.height-1)
    val yMax = clamp(y+radius, 0, src.height-1)
    var (i,j,n) = (xMin, yMin, 0.0)
    var r,g,b,a = 0.0