Here is my C++ code that implements fuzzy substring matching. This might be easier to translate.

class Distance
{
  // various other stuff..

  // get fuzzy substring distance
  size_t subdist(const wstring &needle, const wstring &haystack)
  {
	// prep
	const wchar_t* needle_str = needle.c_str() ;
	size_t needle_len = needle.size() ;
	const wchar_t *haystack_str = haystack.c_str() ;
	size_t haystack_len = haystack.size() ;

	// ensure our static rows are large enough
	ensure_size(haystack_len+1) ;

	// init first row
	std::fill(row1, row1+haystack_len+1, 0) ;

	size_t cost = 0;

	// Fill the matrix costs
	for (size_t i = 0; i < needle_len; ++i)
	{
		row2[0] = i+1;

		for (size_t j = 0; j < haystack_len; ++j)
		{
			cost = 1;
			if (needle_str[i] == haystack_str[j])
			{
				cost = 0;
			}

			row2[j+1] = min3(row1[j+1]+1, //  deletion
							 row2[j]+1, // insertion
							 row1[j]+cost) // substitution
							;
		}
		// row1 = row2
		std::swap(row1, row2) ;
	}

	// return lowest cost on bottom row
	return *std::min_element(row1, row1+haystack_len+1) ;
  }

  // make sure our rows are at least large enough to hold needle & haystack
  void ensure_size(size_t min_row_size)
  {
	if (m_row_size < min_row_size)
	{
		if (row1)
		{
			free(row1) ;
		}
		if (row2)
		{
			free(row2) ;
		}
		m_row_size = min_row_size;
		row1 = (size_t*)calloc(m_row_size, sizeof(size_t));
		row2 = (size_t*)calloc(m_row_size, sizeof(size_t));
		if (!row1 || !row2) // Allocation failed
		{
			throw std::bad_alloc("Failed to allocated memory for Distance test") ;
		}
	}
  }
  // Convenience function to get min of 3 values
  size_t min3( size_t a, size_t b, size_t c ) const
  {
	return std::min(std::min(a, b), c) ;
  }
}

 public static int FuzzySubstring(this string needle, string haystack, IUnityContainer container)
        {
            int result = -1;
            try
            {
                int nlen = needle.Length;
                int hlen = haystack.Length;
                if (hlen == 0)
                    return -1;
                if (nlen == 1)
                    return haystack.IndexOf(needle);

                var row1 = new List(new int[hlen + 1]);

                for (int i = 0; i < nlen; ++i)
                {
                    var row2 = new List(new int[i + 1]);
                    for (int j = 0; j < hlen; ++j)
                    {
                        int cost = needle[i] != haystack[j] ? 1 : 0;
                        row2.Add(Math.Min(row1[j + 1] + 1, Math.Min(row2[j] + 1, row1[j] + cost)));
                    }
                    SwapLists(row1,row2);
                }
                result = row1.Min();
            }
            catch (Exception exception)
            {
                container.Resolve().Error(exception.Message);
                throw;
            }
            return result;
        }

        static void SwapLists(List list1, List list2)
        {
            List temp = new List(list1);
            list1.Clear();
            list1.AddRange(list2);
            list2.Clear();
            list2.AddRange(temp);
        }

        public static int FuzzySubstring(this string needle, string haystack, IUnityContainer container)
        {
            int result = -1;
            try
            {
                int nlen = needle.Length;
                int hlen = haystack.Length;
                if (hlen == 0)
                    return -1;
                if (nlen == 1)
                    return haystack.IndexOf(needle);

                var row1 = new List(hlen + 1);

                for (int i = 0; i < nlen; ++i)
                {
                    var row2 = new List(i + 1);
                    for (int j = 0; j < hlen; ++j)
                    {
                        int cost = needle[i] != haystack[j] ? +1 : 0;
                        var one = row1[j + 1] + 1;
                        var two =  Math.Min(row2[j] + 1, row1[j] + cost);
                        var three= Math.Min(one,two);

                        row2.Add(three);
                    }
                    SwapLists(row1,row2);
                }
                result = row1.Min();
            }
            catch (Exception exception)
            {
                container.Resolve().Error(exception.Message);
                throw;
            }
            return result;
        }

        static void SwapLists(List list1, List list2)
        {
            List temp = new List(list1);
            list1.Clear();
            list1.AddRange(list2);
            list2.Clear();
            list2.AddRange(temp);
        }

It makes sense that this is not bi-directional, because it’s for matching substrings. It should be bi-directional if both strings are of the same length, as you pointed out.

Most importantly: the original Levenshtein is bi-directional, meaning that Levenshtein(a,b) == Levenshtein(b,a)

However with your modification, this is no longer the case! In other words, FuzzyLevenshtein(a,b) != FuzzyLevenshtein(b,a)

From my experiments, it appears that FuzzyLevenshtein(a,b) can/will be a lower value when b (the target) has extra characters in its prefix/suffix.
When a (the source) has the extra characters, then the Fuzzy version is the same as the original.

Does this make sense to you? Do you agree? Thanks!

        public static float GetSubStringSimilarity(string string1, string string2)
        {
            float dis = fuzzy_substring(string1, string2);
            float minLen = string1.Length;
            if (minLen > string2.Length)
                minLen = string2.Length;
            if (minLen == 0.0F)
                return 1.0F;
            else
                return 1.0F - dis / minLen;
        }

http://codepad.org/GFfEVDHu

int fuzzy_substring(const string& needle,
                    const string& haystack) {
    const int nlen = needle.size(),
              hlen = haystack.size();
    if (hlen == 0) return -1;
    if (nlen == 1) return haystack.find(needle);
    vector<int> row1(hlen+1, 0);
    for (int i = 0; i < nlen; ++i) {
        vector<int> row2(1, i+1);
        for (int j = 0; j < hlen; ++j) {
            const int cost = needle[i] != haystack[j];
            row2.push_back(std::min(row1[j+1]+1,
                                    std::min(row2[j]+1,
                                             row1[j]+cost)));
        }
        row1.swap(row2);
    }
    return *std::min_element(row1.begin(), row1.end());
}