'Короткий' тип примитива - бросающий в Java
Не существует встроенного метода для удаления одного элемента из массива, потому что он обычно не нужен. В чем твое дело? Почему вы хотите удалить элемент?
Вы можете написать свой код для этого. Вот пример того, как это сделать, если у вас есть одномерный массив, и вы прекрасно понимаете, что ваш код не будет гибридизуемым:
import mxnet as mx
def remove_element_by_index(data, index):
split_data = mx.nd.split(data, num_outputs=data.shape[0], axis=0)
data_no_element = split_data[:index] + split_data[index + 1:]
return mx.nd.concat(*data_no_element, dim=0)
data = mx.nd.array([1, 2, 3])
print(remove_element_by_index(data, 0))
print(remove_element_by_index(data, 1))
print(remove_element_by_index(data, 2))
По сути, этот код разбивает массив на несколько массивов из 1 элемента. , а затем объединяет его обратно без того, который нужно удалить.
7 ответов
Как объяснено в короткий C# (но также и для других языковых компиляторов также, как Java)
существует предопределенное неявное преобразование от короткого до интервала, долго, плавания или десятичного числа.
Вы не можете неявно преобразовать нелитеральные числовые типы большего размера ресурса хранения к короткому (см. Таблицу Целочисленных типов для размеров ресурса хранения целочисленных типов). Рассмотрите, например, следующие двух коротких X и Y переменных:
short x = 5, y = 12;
следующий оператор присваивания произведет ошибку компиляции, , потому что арифметическое выражение на правой стороне оператора присваивания оценивает к интервалу по умолчанию.
short z = x + y; // Error: no conversion from int to short
Для решения этой проблемы используйте бросок:
short z = (short)(x + y); // OK: explicit conversion
Это возможно, хотя использовать следующие утверждения, где целевая переменная имеет тот же размер ресурса хранения или больший размер ресурса хранения:
int m = x + y;
long n = x + y;
А хороший последующий вопрос:
, "почему арифметическое выражение на правой стороне оператора присваивания оценивает к интервалу по умолчанию"?
А первый ответ может быть найден в:
Классификация и Официально Проверка Целочисленной константы, Сворачивающейся
, спецификация языка Java определяет точно, как представлены целые числа и как целочисленные арифметические выражения должны быть оценены . Это - важное свойство Java, поскольку этот язык программирования был разработан, чтобы использоваться в распределенных приложениях в Интернете. программа Java А требуется, чтобы приводить к тому же результату независимо от целевой машины, выполняющей его .
Напротив, C (и большинство широко используемых языков императивного и объектно-ориентированного программирования) более неаккуратно и оставляет много важных характеристик открытыми. Намерение позади этой неточной спецификации языка ясно. Те же программы C, как предполагается, работают на 16-разрядной, 32-разрядной, или даже 64-разрядной архитектуре путем инстанцирования целочисленной арифметики исходных программ с арифметическими операциями, встроенными в целевом процессоре. Это приводит к намного большему количеству кода eп¬ѓcient, потому что он может использовать доступные операции машины непосредственно. Пока целочисленное соглашение о вычислениях только с числами, являющимися “sufficiently small”, не возникнут никакие несоответствия.
В этом смысле, целочисленная арифметика C является заполнителем, которого не определяет точно спецификация языка программирования, но только полностью инстанцируют путем определения целевой машины.
Java точно определяет, как представлены целые числа и как целочисленная арифметика должна быть вычислена.
Java Integers
--------------------------
Signed | Unsigned
--------------------------
long (64-bit) |
int (32-bit) |
short (16-bit) | char (16-bit)
byte (8-bit) |
Символ является единственным типом беззнаковых целых чисел. Его значения представляют символы Unicode, от
\u0000до\uffff, т.е. от 0 до 2 <глоток> 16 в€ ’1., Если целочисленный оператор имеет операнд типа долго, то другой операнд также преобразовывается для ввода долго. Иначе операция выполняется на операндах интервала типа, если необходимо более короткие операнды преобразовываются в интервал . Правила преобразования точно указаны.
[Из Электронных Примечаний в Теоретической Информатике 82 № 2 (2003)
Blesner-Blech-COCV 2003: сабинский GLESNER, Jan Olaf BLECH,
Fakultät für Informatik,
UniversitГ¤t Карлсруэ
Карлсруэ, Германия]
РЕДАКТИРОВАНИЕ: Хорошо, теперь мы знаем, что это - Java...
Раздел 4.2.2 из состояний Спецификации языка Java:
язык программирования Java обеспечивает много операторов, которые действуют на интегральные значения:
[...]
числовые операторы, которые приводят к значению интервала типа или долго: [...] аддитивные операторы + и - (В§15.18)
, Другими словами, это похоже на C# - оператор сложения (при применении к целочисленным типам) только когда-либо приводит к int или long, который является, почему необходимо бросить для присвоения short переменная.
Исходный ответ (C#)
В C# (Вы не указали язык, таким образом, я предполагаю), единственные операторы сложения на типах примитивов:
int operator +(int x, int y);
uint operator +(uint x, uint y);
long operator +(long x, long y);
ulong operator +(ulong x, ulong y);
float operator +(float x, float y);
double operator +(double x, double y);
Они находятся в спецификации C# 3.0, разделяют 7.7.4. Кроме того, сложение в десятичной форме определяется:
decimal operator +(decimal x, decimal y);
(Дополнение перечисления, конкатенация строк и комбинация делегата также определяются там.)
, Как Вы видите, нет никакого short operator +(short x, short y) оператор - таким образом, оба операнда неявно преобразовываются в интервал, и международная форма используется. Это означает, что результатом является выражение типа "интервал", следовательно потребность бросить.
В C# и Java, арифметическое выражение на правой стороне присвоения оценивает к интервалу по умолчанию. Вот почему необходимо вспомнить короткое, потому что нет никакого неявного интервала формы преобразования к короткому по очевидным причинам.
Учитывая, что, "почему интервалу" вопросом по умолчанию не ответили...
Первый, "по умолчанию" не действительно правильное слово (хотя достаточно близко). Как отмечено VonC, выражение, состоявшее из ints и longs, будет иметь длинный результат. И операция, состоящая из ints/logs и, удваивается, будет иметь двойной результат. Компилятор продвигает условия выражения к любому типу, обеспечивает больший диапазон, и/или точность в результате (типы с плавающей точкой, как предполагают, имеют больший диапазон и точность, чем интеграл, хотя Вы действительно теряете точность, преобразовывающую большой longs для удвоения).
Один протест состоит в том, что это продвижение происходит только для условий, для которых нужно оно. Таким образом в следующем примере, подвыражение 5/4 использует только интегральные значения и выполняется с помощью целочисленной математики, даже при том, что полное выражение включает двойное. Результат не то, что Вы могли бы ожидать...
(5/4) * 1000.0
хорошо, итак, почему байт и короток продвинутый на интервал? Без любых ссылок для резервного копирования меня это происходит из-за практичности: существует ограниченное количество байт-кодов.
"Байт-код", поскольку его имя подразумевает, использует единственный байт для определения операции. Например iadd, который добавляет два ints. В настоящее время 205 кодов операций определяются , и целочисленная математика берет 18 для каждого типа (т.е., 36 общих количеств между целым числом и долго), не считая операторы преобразования.
, Если бы короткий, и байт каждый получил их собственный набор кодов операций, Вы были бы в 241, ограничив способность JVM расшириться. Как я сказал, никакие ссылки для резервного копирования меня на этом, но я подозреваю, что Gosling и др. сказал, "как часто люди на самом деле используют короткие замыкания?" С другой стороны, продвижение байта к интервалу приводит к этому not-so-wonderful эффекту (ожидаемый ответ равняется 96, фактическое-16):
byte x = (byte)0xC0;
System.out.println(x >> 2);
Какой язык Вы используете?
Много C базировались, языки имеют правило, что любое математическое выражение выполняется в интервале размера или больше. Из-за этого, после того как Вы добавляете два коротких замыкания, результат имеет интервал типа. Это вызывает потребность в броске.
Я хотел бы добавить что-то, на что не указали. Java не принимает во внимание значения, в которых Вы дали переменные (2 и 3)...
закорачивают = 2; короткий b = 3; короткий c = + b;
Поэтому насколько Java знает, Вы могли сделанный это...
закорачивают = 32767; короткий b = 32767; короткий c = + b;
, Который был бы вне диапазона коротких, это автополя результат к интервалу becuase, "возможно", что результатом будут больше, чем короткое, но не больше, чем международный Интервал был выбран в качестве "значения по умолчанию" потому что в основном большинство людей привычка трудно кодировать значения выше 2,147,483,647 или ниже-2 147 483 648
В Java каждое числовое выражение, например:
anyPrimitive zas = 1;
anyPrimitive bar = 3;
?? x = zas + bar
x, всегда будет быть по крайней мере int или длинным, если один из элементов сложения был длинным.
Но есть некоторые причуды жесткие
byte a = 1; // 1 is an int, but it won't compile if you use a variable
a += 2; // the shortcut works even when 2 is an int
a++; // the post and pre increment operator work