Level 30. Mga sagot sa mga tanong sa pakikipanayam sa antas ng paksa

Ano ang NaN?

Ang NaN (English Not-a-Number) ay isa sa mga espesyal na estado ng isang floating point number. Ginagamit sa maraming mathematical na library at mathematical coprocessors. Ang kundisyong ito ay maaaring mangyari sa iba't ibang mga kaso, halimbawa, kapag ang isang nakaraang mathematical operation ay nakumpleto na may hindi tiyak na resulta, o kung ang isang numero na hindi nakakatugon sa mga kundisyon ay ipinasok sa isang memory cell.

Alinsunod sa IEEE 754, ang estado na ito ay tinukoy sa pamamagitan ng pagtatakda ng exponent sa nakareserbang halaga na 11...11, at ang mantissa sa anumang bagay maliban sa 0 (ang nakalaan na halaga para sa infinity ng makina). Ang sign at mantissa ay maaaring magdala ng ilang karagdagang impormasyon: maraming mga aklatan ang naglalabas ng "negatibong" NaN bilang -NaN.

Ang mga operasyon na nagreresulta sa NaN bilang tugon ay kinabibilangan ng:

• lahat ng mathematical operations na naglalaman ng NaN bilang isa sa mga operand;
• paghahati ng zero sa zero;
• paghahati ng infinity sa infinity;
• pagpaparami ng zero sa infinity;
• pagdaragdag ng infinity na may infinity ng kabaligtaran na sign;
• pagkalkula ng square root ng isang negatibong numero[1];
• pagkuha ng logarithm ng isang negatibong numero.

Ang ilang mga programming language ay may "silent" at "signal" NaN: ang una, kapag kasangkot sa anumang operasyon, ay nagbabalik ng NaN, ang pangalawa ay nagdudulot ng emergency. Karaniwan, ang "tahimik" o "signal" ay tinutukoy ng pinakamahalagang bahagi ng mantissa.

Ang NaN ay hindi katumbas ng anumang iba pang halaga (kahit ang sarili nito[2]); Alinsunod dito, ang pinakasimpleng paraan ng pagsuri ng isang resulta para sa NaN ay upang ihambing ang nagresultang halaga sa sarili nito.

Ang pag-uugali ng iba pang mga operator ng paghahambing ay nag-iiba ayon sa wika. Ang ilang mga wika ay gumagawa ng false[3] (upang ang isang <b at b > a ay kumilos nang iba sa NaN), ang iba ay naghagis ng pag-crash kahit para sa "tahimik" na NaN.

Anumang di-trivial na operasyon na tumatagal ng isang tahimik na NaN bilang isang argumento ay palaging magbabalik ng NaN, anuman ang halaga ng iba pang mga argumento. Ang tanging pagbubukod sa panuntunang ito ay ang max at min na mga function, na nagbabalik ng halaga ng "pangalawang" argumento (maliban sa NaN). Ang mga trivial na operasyon na mga pagkakakilanlan ay espesyal na tinatrato: halimbawa, ang 1NaN ay katumbas ng 1.

Paano makakuha ng infinity sa Java?

Sa Java, ang uri doubleay may mga espesyal na kahulugan para sa plus infinity at minus infinity. Ang isang positibong numero na hinati sa 0.0 ay nagbibigay ng "plus infinity", at isang negatibong numero - "minus infinity". Ang mga konseptong ito ay tumutugma sa mga espesyal na pare-pareho ng uri Double:

1. Kino-convert namin ang string sa isang numero, at naglalaman ito ng mga titik. Ang sagot ay NaN
2. Infinity minus infinity. Ang sagot ay NaN
3. Mayroong maraming iba pang mga sitwasyon kung saan inaasahan nila ang isang numero sa sagot, ngunit ang resulta ay hindi alam.

Anumang operasyon na naglalaman ng NaN ay nagreresulta sa NaN.

Как проверить, что в результате вычисления получилась бесконечность?

Есть ответ на StackOverFlow.

Все сводится к выводу System.out.println()

What такое битовая маска?

Битовая маска — это когда хранится много различных логических значений (true/false) в виде одного целого числа. При этом каждому boolean-значению соответствует определенный бит.

Где применяют битовые маски?

В основном там, где надо компактно хранить много информации об an objectх. Когда хранишь много информации об an objectе, всегда наберется пара десятков логических переменных. Вот их всех удобно хранить в одном числе. Именно хранить. Т.к. пользоваться им в работе не так уж удобно.

Как установить бит в единицу в битовой маске?

Опираясь на лекции можно ответить таким codeом:

Здесь использовал метод Integer.toBinaryString(), дабы проверить себя, а вдруг)

public class BitMask {

    public static void main(String[] args) {
        int a = 9;

       a |= (1<<2); // установить в 1 бит 2


        System.out.println(Integer.toBinaryString(a) + " "+ a);
    }
}

Вывод такой:

1101 13

Как установить бит в ноль в битовой маске?

public class BitMask {

public static void main(String[] args) {
int a = 15;

a &= ~(1<<2); // установить в 0 бит 2
System.out.println(Integer.toBinaryString(a) + " "+ a);

    }
}

Вывод:

1011 11

Я взял число 15, так How на нем более наглядно видно, куда устанавливается 0.

Как получить meaning определенного бита в битовой маске?

public class BitMask {

public static void main(String[] args) {
     int a = 15;

     a &= ~(1<<2); // установить в 0 бит 2

     int c = a & (1<<2); // узнаем про 2 бит
     int d = a & (1<<3); // узнаем про 3 бит
    System.out.println(Integer.toBinaryString(a) + " "+ a + " " + c +" "+ d);

    }
}

Вывод:

1011 11 0 8

C 0 все понятно, на том месте и вправду 0. А переменная d возвращает meaning запрашиваемого бита (в 10-ой системе).

What такое ленивое вычисление выражения?

Статья: Ленивое программирование и ленивые вычисления

Это ленивые вычисления (lazy evaluation). В ленивых вычислениях ни один параметр не вычисляется, пока в нем нет необходимости. Программы фактически начинаются с конца и работают от конца к началу. Программа вычисляет, что должно быть возвращено, и продолжает движение назад, чтобы определить, Howое meaning для этого требуется. В сущности каждая функция вызывается с promise'ами для каждого параметра. Когда для вычисления необходимо meaning, тогда выполняется promise. Поскольку code выполняется только тогда, когда необходимо meaning, это называется вызов по необходимости (call-by-need). В традиционных языках программирования instead of promise'ов передаются значения, это называется вызов по значению(call-by-value).

Технология программирования "вызов по необходимости" имеет ряд преимуществ. Потоки имплементируются автоматически. Ненужные значения никогда не вычисляются. Однако, поведение ленивых программ часто трудно предсказать. В программах типа "вызов по значению" порядок вычисления довольно предсказуем, поэтому любые time- or sequence-based вычисления относительно легко имплемнтировать. В ленивых языках, где специальные конструкции, например, monads, необходимы для описания явно упорядоченных событий, это намного труднее. Все это также делает связь с другими языками более трудной.

Существуют языки программирования, например, Haskell и Clean, использующие ленивое программирование по умолчанию. Кроме того, для некоторых языков, таких How Scheme, ML и другие, существуют ленивые версии.

Иногда, откладывая вычисления до тех пор, пока не понадобится их meaning, вы можете оптимизировать speed выполнения программы or реструктурировать программу в более понятную форму. Несмотря на свою ценность, методы ленивого программирования не слишком широко используются or даже не очень известны. Подумайте о том, чтобы добавить их в ваш арсенал.

Чем отличается использование && и & для типа boolean?

&& — это логическое «и». (В этом случае имеют место ленивые вычисления: некоторые вычисления опускаются, когда результат и так ясен)

& — это побитовое «и» (Если применить этот оператор к переменным типа Boolean, то ленивых вычислений происходить не будет)