Преобразование некоторых LISP в C #

Question

Я читаю План Пола Грэма о спаме и хочу понять его лучше, но мой LISP действительно ржавый. У него есть фрагмент кода, который вычисляет вероятность как таковую:

(let ((g (* 2 (or (gethash word good) 0)))
      (b (or (gethash word bad) 0)))
   (unless (< (+ g b) 5)
     (max .01
          (min .99 (float (/ (min 1 (/ b nbad))
                             (+ (min 1 (/ g ngood))   
                                (min 1 (/ b nbad)))))))))

У меня двоякий вопрос: (1) есть ли веб-ресурс, который будет конвертировать LISP на другой язык? (я бы предпочел, чтобы это был язык на основе C) или не смог (2) может кто-нибудь переписать этот фрагмент кода в C # для меня?

Answer 1

Я думаю, что-то вроде этого (предупреждение, возможные ошибки впереди. Этот фрагмент предназначен как руководство, а не решение):

var g = 2 * (gethash(word, good) | 0);
var b = gethash(word, bad) | 0;

if( (g + b) >= 5)
{
    return Math.Max( 
        0.01, 
        Math.Min(0.99, 
            Math.Min(1, b / nbad) / 
            (Math.Min(1, g / ngood) + Math.Min(1, b / nbad))));
}

Answer 2

Добавляя к ответ Гонсолы , не забывайте, что Лисп предоставляет целые числа и рациональные числа бесконечной точности, в то время как C # любит усекать. Чтобы получить сравнимые (хотя и не идентичные) результаты, вам нужно будет разыграть 'nbad' и 'ngood', чтобы получить плавающие результаты.

Вы также можете поместить всю конвертированную программу в отмеченный регион. C # даже не предупреждает о переполнении fixnum - первое приближение будет относиться к переполнению, как будто вы ограничены в памяти (в Lisp, если переполнение дает слишком большое число, чтобы поместиться в оставшейся памяти, результаты аналогичного поведения).

checked {
    var fbad = (double)nbad;
    var fgood = (double)ngood;
    var g = 2 * (gethash(word, good) | 0);
    var b = gethash(word, bad) | 0;


    if( (g + b) >= 5)
    {
        return Math.Max( 
            0.01, 
            Math.Min(0.99, 
                    Math.Min(1, b / fbad) / 
                    (Math.Min(1, g / fgood) + Math.Min(1, b / fbad))));
    }
}