source: branches/2929_PrioritizedGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.PGE/3.3/go-code/go-pge/plug/pge.go @ 16230

package main

import "C"
import (
  "pge"
  "unsafe"
  "fmt"
  rt "runtime"
  rand "math/rand"
  "strings"
  probs "github.com/verdverm/go-pge/problems"
)

func main() {

}

var cps *pge.PgeSearch
var tp *probs.TreeParams
var epcomm *probs.ExprProblemComm
var trainDatas []*probs.PointSet
var testDatas []*probs.PointSet
var testDatasN int
var trainDatasN int
var ep *probs.ExprProblem
var per_eqns []*probs.ExprReportArray

var trainData *probs.PointSet
var testData *probs.PointSet

var probIndepNames []string
var probDepndNames []string

var stepResult []*pge.PeelResult
var lastStepRes *pge.PeelResult
var resultNr int

var nCurrentCoeff int 
var nMaxCoeff int

//export InitSearch
func InitSearch(maxGen int, pgeRptEpoch int, pgeRptCount int, pgeArchiveCap int, peelCnt int, evalrCount int, zeroEpsilon float64, initMethod *C.char, growMethod *C.char, sortType int) {
  cps = new(pge.PgeSearch)
  
  goInitMethod := C.GoString(initMethod);
  goGrowMethod := C.GoString(growMethod);
  
  testDatasN = 0 
  trainDatasN = 0

  cps.CreateDS(maxGen, pgeRptEpoch, pgeRptCount, pgeArchiveCap, peelCnt, evalrCount, zeroEpsilon, goInitMethod, goGrowMethod, sortType)
  
  cps.SetPeelCount(peelCnt)
  cps.SetGrowMethod(goGrowMethod)
  cps.SetInitMethod(goInitMethod)
  cps.SetEvalrCount(evalrCount)
}

//export InitTreeParams
func InitTreeParams(Roots *C.char, Nodes *C.char, NonTrig *C.char, Leafs *C.char, UsableVars unsafe.Pointer, nUseableVars int, MaxSize int, MinSize int, MaxDepth int, MinDepth int) {
  tp = new(probs.TreeParams)
  goRoots := C.GoString(Roots)
  goNodes := C.GoString(Nodes)
  goNonTrig := C.GoString(NonTrig)
  goLeafs := C.GoString(Leafs)
  goUsableVars := CIntArrayToSlice(UsableVars, nUseableVars)
  tp.CreateTreeParams(goRoots, goNodes, goNonTrig, goLeafs, goUsableVars, MaxSize, MinSize, MaxDepth, MinDepth)
}

//export AddTrainData
func AddTrainData(indepNames *C.char, depndNames *C.char, matrix unsafe.Pointer, nEntries int) {
  trainDatas = make([]*probs.PointSet, 1)
  trainData = new(probs.PointSet)
  
  goIndepNames := strings.Split(C.GoString(indepNames), " ")
  goDepndNames := strings.Split(C.GoString(depndNames), " ")
  
  probIndepNames = goIndepNames
  probDepndNames = goDepndNames
  
  trainData.InitTrainDataF(goIndepNames, goDepndNames, matrix, nEntries)
  
  trainDatas[trainDatasN] = trainData
  trainDatasN++
}

//export AddTestData
func AddTestData(indepNames *C.char, depndNames *C.char, matrix unsafe.Pointer, nEntries int) {
  testDatas = make([]*probs.PointSet, 1)
  testData = new(probs.PointSet)
  
  goIndepNames := strings.Split(C.GoString(indepNames), " ")
  goDepndNames := strings.Split(C.GoString(depndNames), " ")
  
  testData.InitTestDataF(goIndepNames, goDepndNames, matrix, nEntries)
  testDatas[testDatasN] = testData
  testDatasN++
}

//export InitProblem
func InitProblem(Name *C.char, MaxIter int, HitRatio float64, SearchVar int, ProblemTypeString *C.char, numProcs int) { 
  ep = new(probs.ExprProblem) 
  
  //SysNames   []string
  //VarNames []string
  
  ep.IndepNames = probIndepNames
  ep.DepndNames = probDepndNames
  
  goName := C.GoString(Name)
  goProblemTypeString := C.GoString(ProblemTypeString)
  fmt.Printf("1\n")
  
  ep.CreatePS(goName, MaxIter, HitRatio, SearchVar, goProblemTypeString)
  ep.TreeCfg = tp;
  ep.UsableVars = tp.UsableVars
  fmt.Printf("2\n")
  
  cps.SetMaxIter(MaxIter)
  per_eqns = make([]*probs.ExprReportArray, 1)
  fmt.Printf("3\n")
  
  ep.Train = trainDatas
  ep.Test = testDatas
  fmt.Printf("4\n")
  
  initDone := make(chan int)
  rt.GOMAXPROCS(numProcs)
  rand.Seed(rand.Int63())
  fmt.Printf("5\n")
  
  epcomm = new(probs.ExprProblemComm)
  
  epcomm.Cmds = make(chan int)
    epcomm.Rpts = make(chan *probs.ExprReportArray, 64)
  epcomm.Gen = make(chan [2]int, 64)
  fmt.Printf("6\n")
  
  cps.SetProb(ep)
  cps.Init(initDone, ep, "dummy", epcomm)
  fmt.Printf("7\n")
}

//export GetMaxIterW
func GetMaxIterW() int {
  return cps.GetMaxIter()
}

//export SetMaxIterW
func SetMaxIterW(iter int) {
  cps.SetMaxIter(iter)
}

//export SetPeelCountW
func SetPeelCountW(cnt int) {
  cps.SetPeelCount(cnt)
}

//export SetInitMethodW
func SetInitMethodW(init string) {
  cps.SetInitMethod(init)
}

//export SetGrowMethodW
func SetGrowMethodW(grow string) {
  cps.SetGrowMethod(grow)
}

//export SetEvalrCountW
func SetEvalrCountW(cnt int) {
  cps.SetEvalrCount(cnt)
}

//export EvaluateW
func EvaluateW() {
  cps.Evaluate()
}

//export RunW
func RunW() {
  cps.Run()
}

//export LoopW
func LoopW() {
  cps.Loop()
}

//export GetStepResult
func GetStepResult(nobestpush *int, bestnewminerr *int, bestlen1 *int, bestlen2 *int, testscore *int, ncoeff *int) *C.char { // coeff unsafe.Pointer
  *nobestpush = 0
  *bestnewminerr = 0
  *bestlen1 = 0
  *bestlen2 = 0
  *testscore = 0
  
  if resultNr < cps.GetPeelCount() {
    elem := stepResult[resultNr]
    resultNr++
    lastStepRes = elem
    if(elem != nil) {
      if elem.Nobestpush {
        *nobestpush = 1;
      } else {
        if elem.BestNewMinErr {
          *bestnewminerr = 1
        }
        *testscore = elem.TestScore
        *ncoeff = len(elem.Coeff)
        nCurrentCoeff = 0
        nMaxCoeff = len(elem.Coeff)
        *bestlen1 = elem.Bestlen1
        *bestlen2 = elem.Bestlen2
        return C.CString(elem.Expre.String())
      }
    }
  }
  return C.CString("")
}

//export GetCoeffResult
func GetCoeffResult() float64 {
  var res float64 = 0
  if nCurrentCoeff < nMaxCoeff {
    //item := (*float64) (unsafe.Pointer( uintptr(unsafe.Pointer(coeff)) + unsafe.Sizeof(float64(0)) * uintptr(i) ))
    //*item = elem.Coeff[i]
    
    res = lastStepRes.Coeff[nCurrentCoeff]
  }
  nCurrentCoeff++
  return res
}

//export StepW
func StepW() {
  resultNr = 0
  stepResult = cps.SingleStep()
}

//export CheckStop
func CheckStop() bool {
  if cps.GetIter() > GetMaxIterW() {
    return true
  }
  return false  
}

func CIntArrayToSlice(matrix unsafe.Pointer, nEntries int) []int {
  res := make([]int, nEntries)
  for i := 0; i < nEntries; i++ {
    item := (*int) (unsafe.Pointer( uintptr(unsafe.Pointer(matrix)) + unsafe.Sizeof(int(0)) * uintptr(i) ))
    res[i] = *item
    
    fmt.Printf("USEVAR: %v\n", *item)   
  }
  return res
}


//export TestGet
func TestGet(nix int, nix2 *C.char, nnix2 C.int) {
  fmt.Printf("TEST INT VALUE: %v \n", nix);
  fmt.Printf("TEST STRING VALUE: %v \n", nix2);
  var nixgo string
  nixgo = C.GoString(nix2);//, nnix2);  
  fmt.Printf("TEST STRING AS GOSTR VALUE: %v \n", nixgo);
}

//export CleanW
func CleanW() {
  cps.Clean()
}