нет, суть в том, что мы заменяем вычитание сложением. Например, рассматриваем 4-битные числа. 16 - это по сути ноль (10000b)

заменяем вычитание сложением: a - b = a + 16-b (16-b - дополнение до двойки)

почему же это все-таки работает или что-то типа алгебраического смысла? a + 16-b = 16 + a-b. Т.е. мы к нулю (16) прибавляем положительное (a>b) либо отрицательное (a<b) число и оставляем четыре младших бита результата. А все значения, которые принимает число - зациклены (посмотри на таблицу, вверх - сложение, вниз - вычитание)

а то, что есть альтернативный способ получения дополнения до двойки - это уже другой вопрос. Он делается через дополнение до единиц, а там в качестве точки отсчета выбрано на единицу меньше число. Поэтому сначала дополняем до единиц, а потом прибавляем еще одну единицу

Kolyaj, но мы же не про IEEE 754 разговариваем

Я сейчас бегло просмотрел (сегодня читать уже не буду, спать хочется) и насколько я понял там речь идет об общем 64-х разрядном представлении чисел в котором есть и +0 и -0, а в побитовых операциях числа представляются, насколько я понимаю, в 32-х разрядном знаковом целочисленном формате в котором есть только один ноль, завтра подробно прочитаю статью, может ошибся.

x-yuri,
спасибо за пояснения, завтра буду разбираться дальше, сейчас уже отрубаюсь, позже напишу о результатах :)

-------
update

Все, теперь разобрался! Вобщем смысл такой - мы представляем отрицательные числа в таком виде, чтобы заменить вычитание сложением, т.е. если первое число больше, то при сложении у нас будет переполнение, а значимые биты как раз дадут разность, а если отрицательное больше, то мы при сложении получим меньшее отрицательное число, т.к. положительного "не хватит" чтобы "переполнить". Ну и чтобы это все работало, отрицательные числа мы представляем в "обратном" порядке, начиная с -1 = 1111 (для 4-х разрядного числа), а т.к. у нас в данном случае (речь о побитовых операциях, а не о представлении типа number) нет отрицательного нуля, то чтобы получить отрицательное число мы применяем побитовое НЕ к такому же положительномц, при этом получаем отрицательное число по модулю на 1 больше начального, т.к. отрицательные числа начинаются с -1 а не с нуля и чтобы компенсировать это мы добавляем единицу.

x-yuri,
правильно я все понял-то? (:

да. Скажу только, что я бы назвал вариант перевода с помощью побитового НЕ и прибавления единицы - альтернативным. Основной - вычитание из степени двойки (10000b для 4-хразрядных чисел). А потом уже можно осознать, что побитовое НЕ - это вычитание из 1111b. Отсюда разница в единицу

Ясно, понял, спасибо за объяснения (:

Всем привет!Позвольте и мне вставить 5 копеек. Так же читаю Флэнагана и возник вопрос. Никак не могу разобрать метод call(). Прочел сдесь на сайте - так и не дошло. Первый аргумент как я понял ссылается на объект посредством которого будет выполнен метод. В данном случае атрибут принимает значение null, и объектом соответственно становится window.

function fx(x){return x+x;}
z = 1;
alert(fx.call(null, z));

Дык почему же он зараза не пашет в этом случае?:-/

function fx(x){return x+x;}
var q = {z: 100}
alert(fx.call(q, z));

как миниму, качестве аргумента вы передаете неправильно вызваное свойство объекта

alert(function(x){return x + x}.call(null, {a: 100})); //{a: 100} + {a: 100} - [object Object][object Object]

var x = {a: 100};
alert(function(x){return x.a + x.a}.call(null, x)); //200

alert(function(x){return x + x}.call(null, {a: 100}));// хм... такого синтаксиса не встречал. я про такой ввод {a: 100} непосредственно в аргумент.

Спасибо за ответ но не понял почему этот код не идентичен вышеизложенному.

function f(x){return x+x;}
windows.a =100;
alert(f.call(null,a));

Говорит нет свойства такого. А в вашем примере есть.


но как закодить без изменения функции

{return x + x}

. я имею ввиду без вызова свойства x.a в лоб?:blink:

В моем первом приеме оно работает но только как вызов свойства глобального объекта.

function fx(x){return x+x;}
z = 1;
alert(fx.call(null, z));

потому, что не windows, а window

alert(function(x){return x+x;}.call(null, this.a=100));
alert(function(x){return x+x;}.call(null, window.a=100));

:( мде... ну я и лопух))). с виндовсом как то резко вышло)))
Но все же так для ясности... просто функцию

function(x){return x+x;}

вызвать методом call посредством к примеру a.b = 100; нельзя?

первый аргумент будет доступен через this во время вызова функции

function a( p ){
    alert([ this.b, p ]);
}
a.call({b: 3}, 4);

т.е. с помощью call/apply ты можешь указать, для какого объекта вызвать функцию

все всем спасибо - разобрался!:) не внимательно читал или не понял вначале.

Всем привет, а вот и очередной вопрос, на этот раз общего плана:

Читая про массивы встретил такую строчку - "JavaScript не поддерживает 'настоящие' многомерные массивы, но позволяет имитировать их при помощи массива из массивов." Так вот, подобное я встречаю уже не первый раз (кажется, еще в учебнике по С такое было, может еще где-то) и у меня всегда возникал вопрос, а что же такое "настоящие" многомерные массивы и встречаются ли они в языках программирования?

насколько я понял, есть разные мнения на тему того, что такое "настоящий" массив:

1) предусмотрен ли в языке специальный синтаксис для многомерных массивов (есть ли многомерные массивы на уровне языка). C, например, не проходит по этому критерию, но проходит по следующему

2) как такие массивы реализованы: либо есть один непрерывный блок, хранящий последовательно все значения, либо есть много одномерных массивов, связанных друг с другом. Непрерывный блок может быть лучше с точки зрения производительности, но такие массивы менее гибкие, мало где нужны и мало где остались

по первому критерию, проходит BASIC

но в любом случае, тут не чем хвастаться

а вот как работали с многомерными массивами в perl, пока там не появились ссылки
или

UPD, по поводу первого критерия... C не знает, что такое многомерный массив. Когда ты пишешь int a[5][7], для него это int (a[5])[7]. Т.е. он рассматривает это как массив c элементами типа int[7], просто у C гибкая система типов. Но когда ты в BASIC пишешь DIM A(5,7)... он не может не знать, что это многомерный массив

Ясно, спасибо.

Хотя я так понял - разницы по большому счету нет. Первый критерий вообще получается ни на что не влияет, а второй насколько я понимаю уже умер, т.к. даже в С если делать динамический массив, то под новые элементы надо выделять отдельно память, которая будет располагаться вне начального блока памяти.

ну как, по крайней мере, мне было бы интересно, если бы меня разубедили, что "настоящие" массивы уже не актуальны :)

Ну я этим точно не буду заниматься (: