0

在使用 R 计算数据挖掘技术算法的准确性的大学项目期间，我和我的主管同意实施此处显示的 DP 算法http://www.iwaponline.com/jh/012/0318/0120318.pdf，对于每隔 15 分钟获取的河流高度时间序列，需要一个计算所有分段路径的函数。

在编写此函数“最小化”时，-- 顺便说一句未完成，但仍然有效。我遇到了以下错误“错误：C 堆栈使用量太接近限制”，我不想继续，直到这部分首先工作下面是我的 R 代码，然后是我试图复制的函数的 java 代码进一步遵循示例测试系列是：1,2,3,4,5,4,3,2,1,2,3,4,5 所以 T=13 目前我一直在尝试让示例与 K 一起运行=3，但 Minimize 函数最终将在 K=1 到 K=20 的循环中使用。java中的calerror函数计算我的R代码中每个段的lms错误我还没有实现这个函数所以目前被注释掉了。Minimize 函数的目标是计算每个可能段的误差，并放入一个名为 cost 的数组中，

如果有人知道我为什么会得到并可能纠正这个错误，那么非常需要您的帮助，如果有人对将 JAVA 代码转换为 R 代码有任何建议，也将不胜感激。

#Recursive method for exploring all paths
library(zoo)
fmt = '%d-%b-%Y %H:%M'
data = read.zoo("desktop/test.csv",header=TRUE,sep=',',tz='',format=fmt,index=0:1)
Values = coredata(data) #strips date/time of values for computation 
Number=plain #array of indexed values

T=length(data)
r=1
K=3

Compare = function (START,END){
  if (START<END){
    boo = -1
  }
  if (START==END){
    boo = 0
  }
  if (START>END){
    boo = 1
  }
  return(boo)
}



Minimize = function(T,K,r){
  if(r<K){
  H=T-K+r
    for(r in 1:H){
      START = Number[1]
       END = Number[r]
      boo1=Compare(START,END)
      if (boo1 !=0){
       cost[r]=cost[r-1]#+calerror(START,END)
      }else{
        cost[r]=0
        r=r+1
        Minimize(T,K,r)
      }
    }
}else{
}
  return(cost)
} 
tester=Minimize(T,K,r)
tester

完成的 Java 代码如下：

private void minimize(int T, int K, int k) {
        // recursive method for exploring all the paths
        if(k<K){
            for(t[k]=t[k-1];t[k]<T-K+k-1;t[k]++){
                Map.Entry<Date, V> e = inData.getEntryAtIndex(t[k-1]);
                Map.Entry<Date, V> f = inData.getEntryAtIndex(t[k]+1);
                Interval interval = new Interval(e.getKey(),f.getKey());
                //System.out.println(interval);
                if(interval.getStart().compareTo(interval.getEnd())!=0)
                    cost[k]=cost[k-1]+calError(interval);
                else cost[k] = 0;
                minimize(T,K,k+1);
            }
        }
        else{
            for(t[k]=t[k-1];t[k]<T-K+k-1;t[k]++){
                Map.Entry<Date, V> g = inData.getEntryAtIndex(t[k-1]);
                Map.Entry<Date, V> h = inData.getEntryAtIndex(t[k]+1);
                Interval interval1 = new Interval(g.getKey(),h.getKey());
                //System.out.println(interval1);
                if(interval1.getStart().compareTo(interval1.getEnd())!=0)
                    cost[k]=cost[k-1]+calError(interval1);
                else cost[k] = 0;
                Map.Entry<Date, V> i = inData.getEntryAtIndex(t[k]);
                Map.Entry<Date, V> j = inData.getEntryAtIndex(T-1);
                Interval interval2 = new Interval(i.getKey(),j.getKey());
                if(interval2.getStart().compareTo(interval2.getEnd())!=0)
                    cost[k+1]=cost[k]+calError(interval2);
                else cost[k+1]=0;

                if(ckt[K]>cost[k+1]){
                    /*for(int l=0;l<K+1;l++)
                        System.out.println(ckt[l]);*/
                    ckt[K] = cost[k+1];
                    /*for(int l=0;l<K+1;l++)
                        System.out.println(ckt[l]);*/
                    for(int l=0;l<K+1;l++)
                        tOpti[K][l]=t[l];
                    /*for(int l = 0;l<K+1;l++)
                        System.out.print(tOpti[K][l]+",");
                    System.out.println(ckt[K]);*/
                }
            }
        }
    }
4

0 回答 0