C#, numerical calculation - Hashtable calculation method and source program

1 text format

using System;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer
{
public abstract class Hashtable<K>
{
private int nhash { get; set; }
private int nmax { get; set; }
private int nn { get; set; }
private int ng { get; set; }
private int[] htable { get; set; }
private int[] next { get; set; }
private int[] garbg { get; set; }
private ulong[] thehash { get; set; }

public virtual ulong fn(K k) { return 0L; }

public Hashtable(int nh, int nm)
{
nhash = nh;
nmax = nm;
nn = 0;
ng = 0;
htable = new int[nh];
next = new int[nm];
garbg = new int[nm];
thehash = new ulong[nm];
for (int j = 0; j < nh; j++)
{
htable[j] = -1;
}
}

public int iget(K key)
{ //head pp = hash.fn(key); //head pp = new Hashfn1(nhash).fn(key); head pp = fn(key);

int j = (int)(pp % (ulong)nhash);
for (int k = htable[j]; k != -1; k = next[k])
{
if (thehash[k] == pp)
{
return k;
}
}
return -1;
}

public int iset(K key)
{ int kprev = 0; //head pp = new Hashfn1(nhash).fn(key); head pp = fn(key); int j = (int)(pp % (head)nhash); int k; if (htable[j] == -1) { k = of > 0 ? garbg[--ng] : nn++; htable[j] = k; } else { k = htable[j]; for (; k != -1; k = next[k]) { if (thehash[k] == pp) { return k;

}
kprev = k;
}
k = ng > 0 ? garbg[--ng] : nn++;
next[kprev] = k;
}
if (k >= nmax)
{
throw new Exception("storing too many values");
}
thehash[k] = pp;
next[k] = -1;
return k;
}

public int ierase(K key)
{
//ulong pp = new Hashfn1(nhash).fn(key);
ulong pp = fn(key);
int j = (int)(pp % (ulong)nhash);
if (htable[j] == -1)
{
return -1;
}
int kprev = -1;
for (int k = htable[j]; k != -1; k = next[k])
{
if (thehash[k] == pp)
{
if (kprev == -1)
{
htable[j] = next[k];
}
else
{ next[kprev] = next[k]; } garbg[ng++] = k; return k; } kprev = k; } return -1; }

public int ireserve()
{
int k = ng > 0 ? garbg[--ng] : nn++;
if (k >= nmax)
{
throw new Exception("reserving too many values");
}
next[k] = -2;
return k;
}

public int irelinquish ( int k )
{ if ( next [ k ] ! = - 2 ) { return - 1 ; } garbg[ng++] = k; return k; } } }

2 code format

using System;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer
{
    public abstract class Hashtable<K>
    {
        private int nhash { get; set; }
        private int nmax { get; set; }
        private int nn { get; set; }
        private int ng { get; set; }
        private int[] htable { get; set; }
        private int[] next { get; set; }
        private int[] garbg { get; set; }
        private ulong[] thehash { get; set; }

        public virtual ulong fn(K k) { return 0L; }

        public Hashtable(int nh, int nm)
        {
            nhash = nh;
            nmax = nm;
            nn = 0;
            ng = 0;
            htable = new int[nh];
            next = new int[nm];
            garbg = new int[nm];
            thehash = new ulong[nm];
            for (int j = 0; j < nh; j++)
            {
                htable[j] = -1;
            }
        }

        public int iget(K key)
        {
            //ulong pp = hash.fn(key);
            //ulong pp = new Hashfn1(nhash).fn(key);
            ulong pp = fn(key);

            int j = (int)(pp % (ulong)nhash);
            for (int k = htable[j]; k != -1; k = next[k])
            {
                if (thehash[k] == pp)
                {
                    return k;
                }
            }
            return -1;
        }

        public int iset(K key)
        {
            int kprev = 0;
            //ulong pp = new Hashfn1(nhash).fn(key);
            ulong pp = fn(key);
            int j = (int)(pp % (ulong)nhash);
            int k;
            if (htable[j] == -1)
            {
                k = ng > 0 ? garbg[--ng] : nn++;
                htable[j] = k;
            }
            else
            {
                k = htable[j];
                for (; k != -1; k = next[k])
                {
                    if (thehash[k] == pp)
                    {
                        return k;
                    }
                    kprev = k;
                }
                k = ng > 0 ? garbg[--ng] : nn++;
                next[kprev] = k;
            }
            if (k >= nmax)
            {
                throw new Exception("storing too many values");
            }
            thehash[k] = pp;
            next[k] = -1;
            return k;
        }


        public int ierase(K key)
        {
            //ulong pp = new Hashfn1(nhash).fn(key);
            ulong pp = fn(key);
            int j = (int)(pp % (ulong)nhash);
            if (htable[j] == -1)
            {
                return -1;
            }
            int kprev = -1;
            for (int k = htable[j]; k != -1; k = next[k])
            {
                if (thehash[k] == pp)
                {
                    if (kprev == -1)
                    {
                        htable[j] = next[k];
                    }
                    else
                    {
                        next[kprev] = next[k];
                    }
                    garbg[ng++] = k;
                    return k;
                }
                kprev = k;
            }
            return -1;
        }

        public int ireserve()
        {
            int k = ng > 0 ? garbg[--ng] : nn++;
            if (k >= nmax)
            {
                throw new Exception("reserving too many values");
            }
            next[k] = -2;
            return k;
        }

        public int irelinquish(int k)
        {
            if (next[k] != -2)
            {
                return -1;
            }
            garbg[ng++] = k;
            return k;
        }
    }
}