QBasic. Проблема с циклом и погрешностью

[Clericos]

Здравствуйте.

Выполняя лабораторную (на MS-DOS QBasic v1.0) столкнулся с такой проблемой
Вот элементарный код (все лишнее специально убрал чтобы было проще понять):

FOR X = 1 TO 4 STEP .1
  N = 2 * X
  PRINT "N("; X; ")="; N
NEXT X

END

И вот что получается на выходе:

N( 1 )= 2
N( 1.1 )= 2.2
N( 1.2 )= 2.4
N( 1.3 )= 2.6
N( 1.4 )= 2.8
N( 1.5 )= 3
N( 1.6 )= 3.2
N( 1.7 )= 3.4
N( 1.8 )= 3.6
N( 1.9 )= 3.8
N( 2 )= 4
N( 2.1 )= 4.2
N( 2.2 )= 4.4
N( 2.3 )= 4.6
N( 2.4 )= 4.8
N( 2.5 )= 5
N( 2.6 )= 5.199999
N( 2.7 )= 5.399999
N( 2.799999 )= 5.599999
N( 2.899999 )= 5.799999
N( 2.999999 )= 5.999999
N( 3.099999 )= 6.199998
N( 3.199999 )= 6.399998
N( 3.299999 )= 6.599998
N( 3.399999 )= 6.799998
N( 3.499999 )= 6.999998
N( 3.599999 )= 7.199997
N( 3.699999 )= 7.399997
N( 3.799999 )= 7.599997
N( 3.899998 )= 7.799997
N( 3.999998 )= 7.999997

Т.е. все идет прекрасно до 2.7 а дальше набегает какая-то погрешность.
Это вообще нормально для QBasic?
Просто лабу девушка попросила сделать, теперь непонятно, толи так и должно быть (особенность платформы)? То ли надо как-то объявить переменные...

DEFDBL X
DEFDBL N
FOR X = 1 TO 4 STEP .1#
N = 2 * X
PRINT "N("; X; ")="; N
NEXT X
END

но тогда все превращается в такой бред:

N( 1 )= 2
N( 1.1 )= 2.2
N( 1.2 )= 2.4
N( 1.3 )= 2.600000000000001
N( 1.4 )= 2.800000000000001
N( 1.5 )= 3.000000000000001
N( 1.600000000000001 )= 3.200000000000001
N( 1.700000000000001 )= 3.400000000000001
N( 1.800000000000001 )= 3.600000000000001
N( 1.900000000000001 )= 3.800000000000002
N( 2.000000000000001 )= 4.000000000000002
N( 2.100000000000001 )= 4.200000000000002
N( 2.200000000000001 )= 4.400000000000002
N( 2.300000000000001 )= 4.600000000000002
N( 2.400000000000001 )= 4.800000000000002
N( 2.500000000000001 )= 5.000000000000003
N( 2.600000000000001 )= 5.200000000000003
N( 2.700000000000002 )= 5.400000000000003
N( 2.800000000000002 )= 5.600000000000003
N( 2.900000000000002 )= 5.800000000000003
N( 3.000000000000002 )= 6.000000000000004
N( 3.100000000000002 )= 6.200000000000004
N( 3.200000000000002 )= 6.400000000000004
N( 3.300000000000002 )= 6.600000000000004
N( 3.400000000000002 )= 6.800000000000004
N( 3.500000000000002 )= 7.000000000000004
N( 3.600000000000002 )= 7.200000000000005
N( 3.700000000000002 )= 7.400000000000005
N( 3.800000000000002 )= 7.600000000000005
N( 3.900000000000003 )= 7.800000000000005

В общем простое задание оказалось с сюрпризом.
Может надо просто на старом компьютере запускать?

Заранее спасибо.

[Clericos]

Если у кого есть возможность запустить этот код у себя на qbasic и выложить результат, буду очень благодарен

FOR X = 1 TO 4 STEP .1
N = 2 * X
PRINT "N("; X; ")="; N
NEXT X

END

[Clericos]

Ну раз никих предложений и мыслей нет, так и вставлю в отчет с погрешностью.

...
N( 2.5 )= 5
N( 2.6 )= 5.199999
N( 2.7 )= 5.399999
N( 2.799999 )= 5.599999
N( 2.899999 )= 5.799999
N( 2.999999 )= 5.999999
N( 3.099999 )= 6.199998
N( 3.199999 )= 6.399998
N( 3.299999 )= 6.599998
N( 3.399999 )= 6.799998
N( 3.499999 )= 6.999998
N( 3.599999 )= 7.199997
N( 3.699999 )= 7.399997
N( 3.799999 )= 7.599997
N( 3.899998 )= 7.799997
N( 3.999998 )= 7.999997

[EducatedFool]

Это вообще нормально для QBasic?

Вроде не нормально...
Последний раз пользовался qBasic-ом лет 15 назад - там всё как надо вычислялось..

Могу предложить только такой вариант:

FOR X = 10 TO 40 STEP 1
N = 2 * X/10
PRINT "N("; X/10; ")="; N
NEXT X
END

[Clericos]

Ваш вариант отрабатывает корректно. Я тоже об этом думал, но это не прикладное решение, а лабораторная... и как-то это плохо смотрится, но все равно, большое спасибо

В общем, закончилось все вот так:
Добавил в начало DEFDBL <переменная>- это дало повышенную точность

а в конце дабл преобразовал в сингл при помощи CSNG(<переменная>) - это срезало погрешность

DEFDBL X
DEFDBL N
FOR X = 1 TO 4 STEP .1#
<форула>
PRINT "N("; CSNG(X); ")="; CSNG(N)
NEXT X
END

получилось красиво на выходе, но вообще странно все это как-то.