module GECS

# File lib/GECS.rb, line 682
def GECS.bootstrapMeans(bagOfHolding,id,delta)
  require 'parallel'
  throw "Bag is nil" if bagOfHolding.nil?
  throw "Experiments are nil" if bagOfHolding.experiments.nil?
  throw "No such experiment" if id >= bagOfHolding.experiments.length

  exp = bagOfHolding.experiments[id]
  throw "Null experiment" if exp.nil?
  throw "Null indvars" if exp.indVars.nil?
  throw "Null depvars" if exp.depVars.nil?
  numfacs = exp.indVars.length
  numdeps = exp.depVars.length
  throw "Not enough indvars" if numfacs < 1
  throw "Not enough depvars" if numdeps < 1
  throw "Wrong number of deltas" if delta.length != numdeps

  parmDef = ParmDef.new(bagOfHolding.getOrAddParm("mean"),
    bagOfHolding.getOrAddEstMethod("bootstrap, BCa interval"),
    {bagOfHolding.getOrAddEstMethodParm("coverage probability")=>0.95})
  meanId = bagOfHolding.getOrAddParmDef(parmDef)

  # Make a list of the data and effects that need fixing with a unique
  # serial number assigned to each.
  sernum = 0
  pods = Array.new
  enumerateKeys(bagOfHolding,id).each{|key|
    for di in 0..numdeps-1
      pods.push(ParPod.new(key,di,(sernum+=1),nil))
    end
  }

  # Run numCPUs instances of BCa.R in parallel.
  pods = Parallel.map(pods) do |pod|
    poddata = refactorExtract(bagOfHolding,pod.key,pod.di)
    unless poddata.nil?
      descript = "Treatment " + pod.key.treat.to_s + " depvar " + pod.di.to_s
      fnam = "bootstrap-in-" + pod.sernum.to_s + ".txt"
      fp = File.open(fnam,"w")
      fp.puts(poddata)
      fp.close

      # This R script that has been mangled onto the command line to avoid
      # adding another external dependency is mostly just a wrapper for
      # BCa.R, but the bootstrap estimate of the mean is replaced by the
      # sample mean.
      cmd = "Rscript " +
        "-e 'library(\"bootBCa\")' " +
        "-e 'data <- unlist(read.table(\"" + fnam + "\",header=F,colClasses=\"numeric\"))' " +
        "-e 'out <- BCa(data,as.numeric(" + delta[pod.di].to_s + "),mean)' " +
        "-e 'cat(sprintf(\"%d %0.16f %0.16f %0.16f %0.16f\\n\",out[1],out[2],mean(data),out[4],out[5]))'"

      pod.out = `#{cmd}`.split
      File.delete(fnam)
      if pod.out.length < 5
        # This should never happen.
        print "Bootstrap failure\n"
        print "  ", descript, "\n"
        print "  Depvar: ", bagOfHolding.experiments[id].depVars[pod.di], "\n"
        throw "Bootstrap failure"
      end

      # Verbose progress reporting
      print descript + ", " + pod.out[0] + " iterations done\n"
    end
    pod
  end

  # Copy back parameter estimates.
  bagOfHolding.ests ||= Hash.new
  pods.each{|pod|
    pd = parmRet(bagOfHolding,delta,pod)
    unless pd.nil?
      bagOfHolding.ests[pod.key] ||= Array.new(numdeps,nil)
      bagOfHolding.ests[pod.key][pod.di] ||= Hash.new
      bagOfHolding.ests[pod.key][pod.di][meanId] = pd
    end
  }
end

# File lib/GECS.rb, line 420
def GECS.describeParms(bagOfHolding,id)
  experiment = bagOfHolding.experiments[id]
  ests = bagOfHolding.ests.select{|k,v| k.experimentId==id}
  ests.each{|k,v|
    print "Treatment " + k.treat.to_s + "\n"
    v.each_index{|di|
      print "  Depvar ", experiment.depVars[di], "\n"
      if v[di].nil?
        print "    Not applicable\n"
      else
        v[di].each{|pk,parmData|
          parmDef = bagOfHolding.parmDefs[pk]
          print "    Parameter: ", bagOfHolding.parms[parmDef.parm], "\n"
          print "    Estimation method: ", bagOfHolding.estMethods[parmDef.estMethod], "\n"
          print "    Global estimation method parameters:", "\n"
          printEstMethodParms(bagOfHolding, parmDef.estMethodParms)
          print "    Local estimation method parameters:", "\n"
          printEstMethodParms(bagOfHolding, parmData.estMethodParms)
        }
      end
    }
  }
end

# File lib/GECS.rb, line 311
def GECS.dumpData(bagOfHolding,id)
  throw "Bag is nil" if bagOfHolding.nil?
  throw "Experiments are nil" if bagOfHolding.experiments.nil?
  throw "No such experiment" if id >= bagOfHolding.experiments.length
  exp = bagOfHolding.experiments[id]
  raise "Experiment has no independent variables!" if exp.indVars.empty?
  raise "Experiment has no dependent variables!" if exp.depVars.empty?
  dump = quotesome(exp.indVars) + " " + quotesome(exp.depVars) + "\n"
  results = bagOfHolding.data.select{|k,v| k.experimentId==id}
  results.each{|k,cellarray|
    raise "Null treatment data" if cellarray.nil?
    raise "Bad treatment data" if cellarray.length != exp.depVars.length
    maxlen = cellarray.map{|cell| cell.nil? ? 1 : cell.length}.max
    for iteration in 0..maxlen-1
      dump << quotesome(k.treat)
      cellarray.each{|cell|
        dump << " " + quotemaybe(cell.nil? ? nil : cell[iteration]).to_s
      }
      dump << "\n"
    end
  }
  dump
end

# File lib/GECS.rb, line 340
def GECS.dumpParms(bagOfHolding,id,prec=false)
  throw "Bag is nil" if bagOfHolding.nil?
  throw "Experiments are nil" if bagOfHolding.experiments.nil?
  throw "No such experiment" if id >= bagOfHolding.experiments.length
  experiment = bagOfHolding.experiments[id]
  ests = bagOfHolding.ests.select{|k,v| k.experimentId==id}
  parms = ests[ests.keys[0]][0].keys.sort
  precparm = bagOfHolding.getOrAddEstMethodParm("estimated attained precision of adaptive bootstrap") if prec
  dump = "# Key to parameter ID numbers:\n"
  parms.each{|x|
    parmDef = bagOfHolding.parmDefs[x]
    dump += "# " + x.to_s + " = " + bagOfHolding.parms[parmDef.parm] +
                            ", " + bagOfHolding.estMethods[parmDef.estMethod]
    parmDef.estMethodParms.each{|k,v|
      dump += ", " + bagOfHolding.estMethodParms[k] + "=" + v.to_s
    }
    dump += "\n"
  }
  dump += quotesome(experiment.indVars)
  experiment.depVars.each{|d|
    parms.each{|p|
      dump += " \"" + d + " " + p.to_s + " est\"" +
              " \"" + d + " " + p.to_s + " lo\"" +
              " \"" + d + " " + p.to_s + " hi\""
      dump += " \"" + d + " " + p.to_s + " prec\"" if prec
    }
  }
  dump += "\n"
  ests.each{|k,cells|
    dump += quotesome(k.treat)
    cells.each{|cell|
      parms.each{|p|
        if cell.nil?
          dump += " NA NA NA"
          dump += " NA" if prec
        else
          parm = cell[p]
          dump += " " + quotemaybe(parm.est).to_s + " " + quotemaybe(parm.lo).to_s + " " + quotemaybe(parm.hi).to_s
          if prec
            if parm.estMethodParms.nil?
              dump += " NA"
            else
              dump += " " + quotemaybe(parm.estMethodParms[precparm]).to_s
            end
          end
        end
      }
    }
    dump += "\n"
  }
  dump
end

# File lib/GECS.rb, line 509
def GECS.enumerateKeys(bagOfHolding,id)
  require 'set'
  throw "Bag is nil" if bagOfHolding.nil?
  throw "Experiments are nil" if bagOfHolding.experiments.nil?
  throw "No such experiment" if id >= bagOfHolding.experiments.length

  exp = bagOfHolding.experiments[id]
  throw "Null experiment" if exp.nil?
  throw "Null indvars" if exp.indVars.nil?
  throw "Null depvars" if exp.depVars.nil?
  numfacs = exp.indVars.length
  numdeps = exp.depVars.length
  throw "Not enough indvars" if numfacs < 1
  throw "Not enough depvars" if numdeps < 1

  if numfacs==1
    # Short cut for single-factor experiments.
    bagOfHolding.data.select{|k,v| k.experimentId==id}.keys
  else
    # Enumerate the levels of all of the factors while adding all of the
    # treatments.
    r = Array.new
    levels = Array.new(numfacs){Set.new}
    bagOfHolding.data.each_key{|k|
      if k.experimentId==id
        r.push(k)
        for fac in 0..numfacs-1
          levels[fac].add(k.treat[fac])
        end
      end
    }

    treat = Array.new(numfacs,nil)
    # Main effects.  Single-factor experiments were already excluded.
    for fac in 0..numfacs-1
      treat.fill(nil)
      for lvl in levels[fac]
        treat[fac] = lvl
        r.push(Key.new(id,Array.new(treat)))
      end
    end
    # 2-way interactions.
    if numfacs > 2  # Don't duplicate the treatments when numfacs==2.
      for fac1 in 0..numfacs-2
        for fac2 in fac1+1..numfacs-1
          treat.fill(nil)
          for lvl1 in levels[fac1]
            treat[fac1] = lvl1
            for lvl2 in levels[fac2]
              treat[fac2] = lvl2
              key = Key.new(id,Array.new(treat))
              r.push(key) if matchesSomething(bagOfHolding,key)
            end
          end
        end
      end
    end
    r
  end
end

# File lib/GECS.rb, line 290
def GECS.load(filename)
  temp = Marshal.load(File.open(filename,"r"))
  if temp.version > Version
    raise "File format version is later than GECS.rb version"
  end
  temp.bagOfHolding
end

# File lib/GECS.rb, line 491
def GECS.matchesSomething(bagOfHolding,key)
  id = key.experimentId
  bagOfHolding.data.each{|k,v|
    if k.experimentId==id
      if treatEq(key.treat,k.treat)
        unless v.nil?
          return true  # Need to check every v[di] too?
        end
      end
    end
  }
  false
end

# File lib/GECS.rb, line 304
def GECS.newBag(experiments,data)
  BagOfHolding.new(nil, nil, nil, nil, nil, experiments, data, nil)
end

# File lib/GECS.rb, line 655
def GECS.parmRet(bagOfHolding,delta,pod)
  if pod.out.nil?
    nil
  else
    ParmData.new(pod.out[2].to_f, pod.out[3].to_f, pod.out[4].to_f, {
      bagOfHolding.getOrAddEstMethodParm("bootstrap replica count")=>pod.out[0].to_i,
      bagOfHolding.getOrAddEstMethodParm("numerical tolerance of adaptive bootstrap")=>delta[pod.di],
      bagOfHolding.getOrAddEstMethodParm("estimated attained precision of adaptive bootstrap")=>pod.out[1].to_f})
  end
end

# File lib/GECS.rb, line 445
def GECS.printEstMethodParms(bagOfHolding,estMethodParms)
  if estMethodParms.nil?
    puts "      nil"
  else
    estMethodParms.each{|k,v|
      print "      ", bagOfHolding.estMethodParms[k], " = ", v, "\n"
    }
  end
end

# File lib/GECS.rb, line 591
def GECS.quickInterval(data)
  require 'statistics2'
  if data.nil?
    nil
  else
     count = data.length
     sum = data.reduce(:+)
     mean = sum.to_f/count
     variance = data.map{|x| (mean-x)**2}.inject(:+)/(count-1.0)
     meanU = Math.sqrt(variance/count)*Statistics2::ptdist(count-1,0.975)
     ParmData.new(mean,mean-meanU,mean+meanU,nil)
  end
end

# File lib/GECS.rb, line 613
def GECS.quickMeans(bagOfHolding,id)
  throw "Bag is nil" if bagOfHolding.nil?
  throw "Experiments are nil" if bagOfHolding.experiments.nil?
  throw "No such experiment" if id >= bagOfHolding.experiments.length

  exp = bagOfHolding.experiments[id]
  throw "Null experiment" if exp.nil?
  throw "Null indvars" if exp.indVars.nil?
  throw "Null depvars" if exp.depVars.nil?
  numfacs = exp.indVars.length
  numdeps = exp.depVars.length
  throw "Not enough indvars" if numfacs < 1
  throw "Not enough depvars" if numdeps < 1

  parmDef = ParmDef.new(bagOfHolding.getOrAddParm("mean"),
    bagOfHolding.getOrAddEstMethod("original"),
    {bagOfHolding.getOrAddEstMethodParm("coverage probability")=>0.95})
  meanId = bagOfHolding.getOrAddParmDef(parmDef)
  bagOfHolding.ests ||= Hash.new
  enumerateKeys(bagOfHolding,id).each{|key|
    bagOfHolding.ests[key] ||= Array.new(numdeps,nil)
    for di in 0..numdeps-1
      cell = refactorExtract(bagOfHolding,key,di)
      unless cell.nil?
        bagOfHolding.ests[key][di] ||= Hash.new
        bagOfHolding.ests[key][di][meanId] = quickInterval(cell)
      end
    end
  }
end

# File lib/GECS.rb, line 396
def GECS.quotemaybe(oneval)
  if oneval.nil?
    "NA"
  elsif oneval.is_a?(String)
    # R 3.0.2 looks like it is re-escaping strings on input so that \\
    # turns into \\\\, yet this is the minimum amount of escaping that gets
    # everything through read.table without choking.  allowEscapes=F only
    # makes it choke even more.  The worst case seems to be when a string
    # ends with a backslash.
    "\""+oneval.gsub('\\'){'\\\\'}.gsub("\"","\\\"")+"\""
  else
    oneval
  end
end

# File lib/GECS.rb, line 415
def GECS.quotesome(treat)
  treat.map{|level| quotemaybe(level)}.join(" ")
end

# File lib/GECS.rb, line 474
def GECS.refactorExtract(bagOfHolding,key,di)
  id = key.experimentId
  r = nil
  bagOfHolding.data.each{|k,v|
    if k.experimentId==id
      if treatEq(key.treat,k.treat)
        unless v.nil? or v[di].nil?
          r ||= Array.new
          r.concat(v[di])
        end
      end
    end
  }
  r
end

# File lib/GECS.rb, line 285
def GECS.save(filename, bagOfHolding)
  Marshal.dump(DoubleBag.new(Version,bagOfHolding), open(filename,"w"))
end

# File lib/GECS.rb, line 460
def GECS.treatEq(a,b)
  throw "Nil treatment passed to treatEq" if a.nil? or b.nil?
  throw "Length mismatch" if a.length != b.length
  a.each_index{|i|
    return false if !a[i].nil? and !b[i].nil? and a[i]!=b[i]
  }
  true
end