public static QueueElement allc_from_heap(Heap H)
{
if (H.elem_size >= H.capacity)
{
return null;
}
else
{
return H.elem_list[++H.elem_size];
}
}
public DecoderTagger(int nbest, int this_crf_max_word_num = Utils.DEFAULT_CRF_MAX_WORD_NUM)
{
crf_max_word_num = this_crf_max_word_num;
vlevel_ = 0;
nbest_ = nbest;
cost_ = 0.0;
Z_ = 0;
ysize_ = 0;
word_num = 0;
heap_queue = null;
node_ = null;
x_ = null;
result_ = null;
}
public static int heap_insert(QueueElement qe, Heap H)
{
if (H.size >= H.capacity)
{
return Utils.ERROR_HEAP_SIZE_TOO_BIG;
}
var i = ++H.size;
while (i != 1 && H.elem_ptr_list[i / 2].fx > qe.fx)
{
H.elem_ptr_list[i] = H.elem_ptr_list[i / 2]; //此时i还没有进行i/2操作
i /= 2;
}
H.elem_ptr_list[i] = qe;
return 0;
}
public static Heap heap_init(int max_size)
{
Heap H;
H = new Heap();
H.capacity = max_size;
H.size = 0;
H.elem_size = 0;
H.elem_ptr_list = new List<QueueElement>(max_size + 1);
H.elem_list = new List<QueueElement>(max_size + 1);
for (var z = 0; z < max_size; z++)
{
H.elem_list.Add(new QueueElement());
H.elem_ptr_list.Add(null);
}
H.elem_list[0].fx = double.MinValue;
H.elem_ptr_list.Add(H.elem_list[0]);
return H;
}
//使用模型初始化tag，必须先使用该函数初始化才能使用add和parse
//正常返回为0， 错误返回<0
public int init_by_model(ModelReader model_p)
{
featureIndex = model_p;
ysize_ = (short)model_p.ysize();
if (nbest_ > 1)
{
//Only allocate heap when nbest is more than 1
heap_queue = Utils.heap_init((int)(crf_max_word_num * ysize_ * ysize_));
}
//Initialize feature set cache according unigram and bigram templates
InitializeFeatureCache();
node_ = new Node[crf_max_word_num, ysize_];
result_ = new short[crf_max_word_num];
//Create node and path cache
for (short cur = 0; cur < crf_max_word_num; cur++)
{
for (short i = 0; i < ysize_; i++)
{
var n = new Node();
node_[cur, i] = n;
n.lpathList = new List<Path>();
n.rpathList = new List<Path>();
n.x = cur;
n.y = i;
}
}
for (var cur = 1; cur < crf_max_word_num; cur++)
{
for (var j = 0; j < ysize_; ++j)
{
for (var i = 0; i < ysize_; ++i)
{
var p = new CRFSharp.Path();
p.add(node_[cur - 1, j], node_[cur, i]);
}
}
}
return Utils.ERROR_SUCCESS;
}
public static QueueElement heap_delete_min(Heap H)
{
var min_elem = H.elem_ptr_list[1]; //堆是从第1号元素开始的
var last_elem = H.elem_ptr_list[H.size--];
int i = 1, ci = 2;
while (ci <= H.size)
{
if (ci < H.size && H.elem_ptr_list[ci].fx > H.elem_ptr_list[ci + 1].fx)
{
ci++;
}
if (last_elem.fx <= H.elem_ptr_list[ci].fx)
{
break;
}
H.elem_ptr_list[i] = H.elem_ptr_list[ci];
i = ci;
ci *= 2;
}
H.elem_ptr_list[i] = last_elem;
return min_elem;
}
public static void heap_reset(Heap H)
{
if (H != null)
{
H.size = 0;
H.elem_size = 0;
}
}
public static void heap_clear(ref Heap H)
{
if (H == null)
{
return;
}
if (H.elem_list != null)
{
H.elem_list = null;
}
if (H.elem_ptr_list != null)
{
H.elem_ptr_list = null;
}
if (H != null)
{
H = null;
}
}
public static QueueElement find_min(Heap H)
{
return H.elem_ptr_list[1];
}
public static bool is_heap_empty(Heap H)
{
return H.size == 0;
}
