Что такое код floatval


(PHP 4 >= 4.2.0, PHP 5)

floatval — Возвращает значение переменной в виде числа с плавающей точкой


Возвращает значение переменной var в виде числа с плавающей точкой float .

Список параметров

Может быть любого скалярного типа. Вы не можете применить floatval() к массивам или объектам.

Возвращаемые значения

Значение заданной переменной в виде числа с плавающей точкой.


Пример #1 Пример использования floatval()

Смотрите также

  • intval() — Возвращает целое значение переменной
  • strval() — Возвращает строковое значение переменной
  • settype() — Присваивает переменной новый тип
  • Манипуляции с типами

Тема: DelZero(Float:floatval)

Опции темы
  • Линейный вид
  • Комбинированный вид
  • Древовидный вид


На «офе» ope задал вопрос:
Функция возвращает число с плавающей точкой. Вопрос: как отрезать ненужные нули? Например я получил 15.140, нужно чтобы осталось только 15.14, или через эту же функцию я получил 1.200 -нужно оставить только 1.2. В совершенстве еще хотелось бы узнать, — как точку в таком числе заменить на запятую?

Я накидал вот такую функцию:

Работает только с положительными числами, отсутствует проверка на MAXFLOAT, но думаю, она бессмысленна, т.к. обрабатывается только 5 знаков после точки (запятой). С отрицательными числами почему-то фигня: отнимает 1 единицу разряда только.


(PHP 4 >= 4.2.0, PHP 5, PHP 7)

floatval — Get float value of a variable


Gets the float value of var .


May be any scalar type. floatval() should not be used on objects, as doing so will emit an E_NOTICE level error and return 1.

Return Values

The float value of the given variable. Empty arrays return 0, non-empty arrays return 1.

Strings will most likely return 0 although this depends on the leftmost characters of the string. The common rules of float casting apply.


Example #1 floatval() Example

Example #2 floatval() non-numeric leftmost characters Example

See Also

  • boolval() — Get the boolean value of a variable
  • intval() — Get the integer value of a variable
  • strval() — Get string value of a variable
  • settype() — Set the type of a variable
  • Type juggling

User Contributed Notes 23 notes

This function takes the last comma or dot (if any) to make a clean float, ignoring thousand separator, currency or any other letter :

if (!$sep) <
return floatval(preg_replace(«/[^0-9]/», «», $num));

return floatval(
preg_replace(«/[^0-9]/», «», substr($num, 0, $sep)) . ‘.’ .
preg_replace(«/[^0-9]/», «», substr($num, $sep+1, strlen($num)))

$num = ‘1.999,369€’;
var_dump(tofloat($num)); // float(1999.369)
$otherNum = ‘126,564,789.33 m²’;
var_dump(tofloat($otherNum)); // float(126564789.33)

you can also use typecasting instead of functions:

To view the very large and very small numbers (eg from a database DECIMAL), without displaying scientific notation, or leading zeros.

FR : Pour afficher les très grand et très petits nombres (ex. depuis une base de données DECIMAL), sans afficher la notation scientifique, ni les zéros non significatifs.

function floattostr ( $val )
preg_match ( «#^([\+\-]|)([0-9]*)(\.([0-9]*?)|)(0*)$#» , trim ( $val ), $o );
return $o [ 1 ]. sprintf ( ‘%d’ , $o [ 2 ]).( $o [ 3 ]!= ‘.’ ? $o [ 3 ]: » );

echo floattostr ( «0000000000000001» );
echo floattostr ( «1.00000000000000» );
echo floattostr ( «0.00000000001000» );
echo floattostr ( «0000.00010000000» );
echo floattostr ( «000000010000000000.00000000000010000000000» );
echo floattostr ( «-0000000000000.1» );
echo floattostr ( «-00000001.100000» );

// result
// 1
// 1
// 0.00000000001
// 0.0001
// 10000000000.0000000000001
// -0.1
// -1.1

Float value less than 0.0001 (0.0000999999999999995) will be converted by floatval to scientific notation (exponential notation):
( floatval ( 0.0000999999999999995 )); # >> float(0,0001)

var_dump ( floatval ( «0.000099» )); # >> float(9.9E-5)

var_dump ((string) floatval ( 0.000099 )); # >> string(6) «9.9E-5»

Easier-to-grasp-function for the ‘,’ problem.

function Getfloat ( $str ) <
if( strstr ( $str , «,» )) <
$str = str_replace ( «.» , «» , $str ); // replace dots (thousand seps) with blancs
$str = str_replace ( «,» , «.» , $str ); // replace ‘,’ with ‘.’

if( preg_match ( «#([0-9\.]+)#» , $str , $match )) < // search for number that may contain '.'
return floatval ( $match [ 0 ]);
> else <
return floatval ( $str ); // take some last chances with floatval

echo Getfloat ( «$ 19.332,35-» ); // will print: 19332.35

// examples:
echo ‘
‘ . floatvaldec ( ‘somthing123.456.789,12Euro’ ) ;
echo ‘
‘ . floatvaldec ( ‘x123,456 789.12 Euro’ , ‘.’ ) ;
echo ‘
‘ . floatvaldec ( ‘123.456 789,12$’ ) ;

locale aware floatval:

function ParseFloat ( $floatString ) <
$LocaleInfo = localeconv ();
$floatString = str_replace ( $LocaleInfo [ «mon_thousands_sep» ] , «» , $floatString );
$floatString = str_replace ( $LocaleInfo [ «mon_decimal_point» ] , «.» , $floatString );
return floatval ( $floatString );

There is much easier way to deal with formatted numbers:

= ‘13,232.95’ ;
$var = (double) filter_var ( $str , FILTER_SANITIZE_NUMBER_FLOAT , FILTER_FLAG_ALLOW_FRACTION );
var_dump ( $var );

The last getFloat() function is not completely correct.

1.000.000 and 1,000,000 and its negative variants are not correctly parsed. For the sake of comparing and to make myself clear I use the name parseFloat in stead of getFloat for the new function:

function parseFloat ( $ptString ) <
if ( strlen ( $ptString ) == 0 ) <
return false ;

$pString = str_replace ( » » , «» , $ptString );

if ( substr_count ( $pString , «,» ) > 1 )
$pString = str_replace ( «,» , «» , $pString );

if ( substr_count ( $pString , «.» ) > 1 )
$pString = str_replace ( «.» , «» , $pString );

$commaset = strpos ( $pString , ‘,’ );
if ( $commaset === false )

$pointset = strpos ( $pString , ‘.’ );
if ( $pointset === false )

$pregResultA = array();
$pregResultB = array();

if ( $pointset $commaset ) <
preg_match ( ‘#(([-]?[0-9]+(\.[0-9])?)+(,[0-9]+)?)#’ , $pString , $pregResultA );
preg_match ( ‘#(([-]?[0-9]+(,[0-9])?)+(\.[0-9]+)?)#’ , $pString , $pregResultB );
if ((isset( $pregResultA [ 0 ]) && (!isset( $pregResultB [ 0 ])
|| strstr ( $preResultA [ 0 ], $pregResultB [ 0 ]) == 0
|| ! $pointset ))) <
$numberString = $pregResultA [ 0 ];
$numberString = str_replace ( ‘.’ , » , $numberString );
$numberString = str_replace ( ‘,’ , ‘.’ , $numberString );
elseif (isset( $pregResultB [ 0 ]) && (!isset( $pregResultA [ 0 ])
|| strstr ( $pregResultB [ 0 ], $preResultA [ 0 ]) == 0
|| ! $commaset )) <
$numberString = $pregResultB [ 0 ];
$numberString = str_replace ( ‘,’ , » , $numberString );
else <
return false ;
$result = (float) $numberString ;
return $result ;

Comparing of float parsing functions with the following function:

function testFloatParsing () <
$floatvals = array(
«22 000,76» ,
«22.000,76» ,
«22,000.76» ,
«22 000» ,
«22,000» ,
«22.000» ,
«22000.76» ,
«22000,76» ,
«1.022.000,76» ,
«1,022,000.76» ,
«1,000,000» ,
«1.000.000» ,
«1022000.76» ,
«1022000,76» ,
«1022000» ,
«0.76» ,
«0,76» ,
«0.00» ,
«0,00» ,
«1.00» ,
«1,00» ,
«-22 000,76» ,
«-22.000,76» ,
«-22,000.76» ,
«-22 000» ,
«-22,000» ,
«-22.000» ,
«-22000.76» ,
«-22000,76» ,
«-1.022.000,76» ,
«-1,022,000.76» ,
«-1,000,000» ,
«-1.000.000» ,
«-1022000.76» ,
«-1022000,76» ,
«-1022000» ,
«-0.76» ,
«-0,76» ,
«-0.00» ,
«-0,00» ,
«-1.00» ,

echo »

» ;

foreach ( $floatvals as $fval ) <
echo »

» ;
echo »

» ;

echo »

» ;
echo »

» ;
echo »

» ;
echo «

» ;
echo «

String floatval() getFloat() parseFloat()
» . (string) $fval . « » . (float) floatval ( $fval ) . « » . (float) getFloat ( $fval ) . « » . (float) parseFloat ( $fval ) . «

» ;

Most of the functions listed here that deal with $ and , are unnecessarily complicated. You can use ereg_replace() to strip out ALL of the characters that will cause floatval to fail in one simple line of code:

= floatval ( ereg_replace ( «[^-0-9\.]» , «» , $input )); ?>

(float) would be more performant here (up to 6x times faster).

intval, floatval, doubleval, strva for PHP4 functions (intval, floatval, doubleval, strval), in PHP5 use type casting construction (i.e. ‘(type) parameter’).

Be aware the last tofloat($num).

In theory it is very useful to have a function «separator-agnostic» (I think «locale based» solutions are useless if you have to parse a user file that can have a locale different to the server).

But this can lead to misinterpretations; in short: «123,456» is «123.456» (so comma used as decimal separator) or «123456» (comma used as thousand separator).

In any case, if you really want to use it, please don’t forget that this function doesn’t manage negative numbers.

= ‘1.299,00 EUR’ ;
//$price = ‘EUR 1.299,00’;
//$price = ‘$1,745.09’;
//$price = ‘$14’;
//$price = ‘$.14’;

function floatValue ( $str ) <
if( preg_match ( «/([0-9\.,-]+)/» , $str , $match )) <
$value = $match [ 0 ];
if( preg_match ( «/(\.\d<1,2>)$/» , $value , $dot_delim ) ) <
$value = (float) str_replace ( ‘,’ , » , $value );
else if( preg_match ( «/(,\d<1,2>)$/» , $value , $comma_delim ) ) <
$value = str_replace ( ‘.’ , » , $value );
$value = (float) str_replace ( ‘,’ , ‘.’ , $value );
$value = (int) $value ;
else <
$value = 0 ;
return $value ;

I get the following disturbing results:
var_dump string(10) «0.01333»
echo the string=0.01333
echo (float)string=0
echo floatval(string)=0

The string is an outcome of array_map(‘str_getcsv’, file(.
I can’t find the characters 8-10

@pillepop2003 at yahoo dot de

( ‘-100.00’ , array( ‘single_dot_as_decimal’ => true )); // whoops, returns -10000

use: «/^[0-9-]*[\.]<1>[0-9-]+$/»
instead of: «/^[0-9]*[\.]<1>[0-9-]+$/»

Use this snippet to extract any float out of a string. You can choose how a single dot is treated with the (bool) ‘single_dot_as_decimal’ directive.
This function should be able to cover almost all floats that appear in an european environment.

function float ( $str , $set = FALSE )
if( preg_match ( «/([0-9\.,-]+)/» , $str , $match ))
// Found number in $str, so set $str that number
$str = $match [ 0 ];

if( strstr ( $str , ‘,’ ))
// A comma exists, that makes it easy, cos we assume it separates the decimal part.
$str = str_replace ( ‘.’ , » , $str ); // Erase thousand seps
$str = str_replace ( ‘,’ , ‘.’ , $str ); // Convert , to . for floatval command

// Else, treat all dots as thousand seps
$str = str_replace ( ‘.’ , » , $str ); // Erase thousand seps
return floatval ( $str );

// No number found, return zero
return 0 ;

echo float ( ‘foo 123,00 bar’ ); // returns 123.00
echo float ( ‘foo 123.00 bar’ array( ‘single_dot_as_decimal’ => TRUE )); //returns 123.000
echo float ( ‘foo 123.00 bar’ array( ‘single_dot_as_decimal’ => FALSE )); //returns 123000
echo float ( ‘foo 222.123.00 bar’ array( ‘single_dot_as_decimal’ => TRUE )); //returns 222123000
echo float ( ‘foo 222.123.00 bar’ array( ‘single_dot_as_decimal’ => FALSE )); //returns 222123000

// The decimal part can also consist of ‘-‘
echo float ( ‘foo 123,— bar’ ); // returns 123.00

[Guide] Определяем Float Value прямо из маркета

Тема в разделе «[CS:GO] Общие вопросы и обсуждения», создана пользователем drowrangerinmyheart, 02 Mar 2020 в 20:26 .

Оценить пост #


Наверняка почти все уже давным-давно знают, что качество скинов в CS:GO делится далеко не на «Закаленное в боях . Прямо с завода», а у каждого из этих промежуточных качеств существует еще масса состояний.
Так скин качества «После полевых испытаний» может быть в 1м грейде от «Немного поношенного», так и в 1м грейде от «Поношенного». И зачастую разница между этими состояниями колоссальна, хотя оба они носят название «После полевых испытаний».

Когда в кс го скины стали только появляться, я просто листал маркет, нажимал «осмотреть в игре» и выбирал шкурку, которая была менее потерта. Чуть позже я стал пользоваться сайтом csgostash.com (там представлено наглядное изменение грейда оружия, по мере уменьшения качества), определял там максимально возможное состояние для нужного мне качества (после полей или немного поношенного) и искал на маркете шмотку, максимально похожую на идеал в данном качестве.

До поры — до времени мне этого вполне хватало.

Однако в последних 3-4 кейсах валвы зачастили со скинами, для которых качество = цвет. Т.е. у них нет сколов и потертостей, есть только степень насыщенности цвета скина. К примеру, мка «голден койл» — https://csgostash.com/skin/657/M4A1-S-Golden-Coil чуть ниже можете посмотреть пример изменения скина с качеством.

И как только валв стали штамповать подобного рода скины, у меня сразу же начались проблемы с определением его состояния.
Т.е. я уже не мог искать сколы и потертости, т.к. их просто не было. А определить, какое оружие из представленных на маркете «ярче» в клиенте игры, лично для меня было весьма проблематично. Да, можно было делать скриншоты и сравнивать, но это долго, все уже раскупали, пока я там нажимал на кнопочки.

И тогда я стал искать способ определить состояние оружия, прямо из стим маркета.

Что такое float value?

Это показатель потертости скина. Чем выше данное значение, тем более потертый/блеклый скин.
Float value есть у абсолютно каждого оружия в игре. Единственные скины, где он присутствует, но не имеет никакого значения — это Vanilla (чистые) ножи. У них тоже есть показатель float value, однако он вообще никак не влияет на их внешний вид, ввиду того, что ванилла текстура наложена поверх текстуры самого ножа, когда у всего остального оружия текстуры скинов наложены под текстуры оружия. Не переплачивайте за Vanilla ножи с низким float value.

Наверняка многие пользователи сайта csgolounge.com сталкивались с таким показателем «condition», который определяет степень потертости скина.

Этот показатель точно определяет состояние оружия.
Рассчитывается он по формуле: «1(0.99 — float value).

Т.е, если float value у скина 0.15, то Condition будет 0.85

Ниже представлена таблица диапазонов состояния скинов для их качества.

0 – 0.55 — Закаленное в боях

0.55 – 0.63 — Поношенное

0.63 – 0.85 — После полевых испытаний

0.85 – 0.93 — Немного поношенное

0.93 – 1 — Прямо с завода.

Т.е, чтобы узнать кондицию скина, достаточно вычесть из единицы показатель float value.

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

Тогда нам нужно найти ее на маркете с показателем float value около 0.15-0.16

Как это сделать?

1. Идем на сайт csgozone.net/#check, выбираем вкладку «Steam market» (ниче не рекламирую, сайт старый + америкосовский).

2. Ищем на маркете нужную нам шмотку

3. Наводим курсор на стрелочку в окошке превью оружия, щелкаем, появляется опция «Осмотреть в игре»

4. Копируем этот линк и вставляем в голубую полоску на сайте «Type in inspect link»

5. Щелкаем «Load item»

P.S. нужно логиниться через стим

И теперь нам показывается полная информация об этом скине — float value, патеррны-индексы (для ножей, в основном) и даже происхождение вашей шмотки (контракты/кейсы).

Отсюда берем показатель float value и отнимает его от единицы.

Если речь идет о вышеупомянутом качестве «после полевых испытаний», то нам нужно будет искать float value максимально близким к 0.15.
Конечно, вряд-ли кто-то способен отличить float value 0.15 от 0.2 на глаз и нет смысла переплачивать за такую разницу, особенно крупные суммы, но ведь диапазон достаточно широк и этот float value может быть аж 0.38, а тут уже разница ощутима даже людям, ничего не понимающим в скинах и CS:GO в целом.

Любые другие состояния шмоток, condition и float value ищутся по аналогии.

Теперь вы умеете определять состояние скинов прямо из стим маркета и больше никогда не купите ft шмотки с ww луком итд.

PHP Преобразование строки в Float / Double

У меня есть список строк (размер в байтах), я читаю их из файла. Скажем, одна из строк – 2968789218, но когда я конвертирую ее в float, она становится 2.00.


На самом деле проблема заключалась в кодировании. Теперь отлично, когда я меняю кодировку файла: D

Удивительно, но ответа нет. Проблема существует только в 32-битном PHP.

Если строка не содержит символов «.», «E» или «E», а числовое значение вписывается в ограничения типа целочисленного типа (как определено PHP_INT_MAX), строка будет оцениваться как целое число. Во всех остальных случаях он будет оцениваться как плавающий.

Другими словами, $string сначала интерпретируется как INT, которая вызывает переполнение (значение $string 2968789218 превышает максимальное значение ( PHP_INT_MAX ) 32-битного PHP, которое равно 2147483647. ), А затем вычисляется как float by (float) или floatval() .

Таким образом, решение:

Чтобы проверить, является ли ваш PHP 32-разрядным или 64-битным, вы можете:

Если ваш PHP 64-бит, он распечатает 9223372036854775807 , иначе он распечатает 2147483647 .

$ float = floatval ($ string);

Если функция floatval не работает, вы можете попробовать сделать следующее:

Что такое код floatval

Float — это свойство CSS для позиционирования элементов. Для того чтобы понять его назначение и происхождение, можно обратиться к полиграфическому дизайну. В компоновке при печати, изображения могут располагаться на странице так, чтобы текст «обтекал» их. Обычно это так и называется: «обтекание текстом».

В программах для вёрстки страниц, элементы с текстом, могут учитывать изображения, а также и игнорировать их. В случае если они будут проигнорированы, текст будет отображаться над картинками, как будто их и нет. Это главная разница между тем, являются ли изображения частью основного потока страницы, или нет. Веб-дизайн очень похож.

В веб-дизайне, элементы страницы с установленным свойством float, ведут себя точно также как и изображения в полиграфии, когда текст «обтекает» их. Такие элементы являются частью основного потока веб-страницы. Однако всё обстоит иначе, если элементы используют абсолютное позиционирование. Абсолютно позиционированные элементы удаляются из основного потока страницы, подобно примеру выше, когда в полиграфии текст игнорирует изображения. Такие элементы не влияют на позицию остальных элементов, соприкасаются они или нет.

Установка свойства float происходит следующим образом:

Всего есть 4 значения для свойства float. Left и right используются для соответствующих направлений. None (по умолчанию) — обеспечивает, что элемент не будет «плавать». И inherit, которое говорит, что поведение должно быть такое же, как и у родительского элемента.

Для чего можно использовать float?

Помимо обтекания текстом изображений, float может использоваться для создания макета всего сайта.

Свойство float также полезно и в меньших масштабах. Для примера рассмотрим маленькую область на странице сайта. Допустим вы используете float для аватара, при изменении размера изображения, размер текста будет подогнан в соответствии с изображением.

Такое же расположение объектов может быть достигнуто путём использования позиционирования. Объекту-контейнеру присваивается относительное (relative) позиционирование, а объекту с изображением — абсолютное (absolute). В этом случае аватар не повлияет на положение текста.

Отмена свойства float

Для float, родственное свойство — clear. Любой элемент, у которого установлено свойство clear, не будет поднят вверх, как от него ожидается, а отобразится ниже, после float-элементов. Возможно, пример на картинке объяснит лучше, чем слова.

В примере, сайд-бар прижат к правому краю (float: right;), а его высота меньше, чем область основного контента. Поэтому footer будет поднят выше, поскольку для него хватает высоты и этого требует поведение float. Чтобы исправить ситуацию, ему необходимо установить свойство clear, которое гарантирует, что элемент выведется ниже float-элементов.

Свойство clear может принимать четыре значения. Both, наиболее используемое, применяется для отмены float каждого из направлений. Left и Right — используются для отмены float одного из направлений. None — по умолчанию, обычно не используется, за исключением случаев, когда необходимо отменить значение clear. Значение inherit было бы пятым значением, но оно странным образом не поддерживается в Internet Explorer. Отмена только левого или правого float, встречается гораздо реже, но, безусловно, имеет свои цели.

Большой коллапс

Ещё одна удивительная вещь при работе со свойством float — это то, что его использование может влиять на родительский элемент. Если такой элемент содержит только float-элементы, то он буквально схлопывается, то есть его высота равна нулю. Это не всегда заметно, если у родительского элемента не установлен какой-либо видимый фон.

Такое схлопывание выглядит нелогичным, однако альтернатива ещё хуже. Рассмотрим такой пример:

Если блочный элемент, располагающийся наверху, будет автоматически увеличиваться, чтобы вместить все float-элементы, то мы получим неестественный разрыв в тексте между параграфами, без всякой возможности это исправить. Если бы было именно так, наши дизайнеры жаловались бы гораздо чаще такому поведению, чем схлопыванию.

Таким образом, схлопывание почти всегда необходимо, чтобы предотвратить трудности в вёрстке. Для того чтобы изменить такое поведение, необходимо добавить элемент отменяющий float после float-элементов, но до закрытия родительского элемента.

Способы отмены float

Если вам известно, что следом после float-элементов, всегда будет выводится какой-либо другой элемент (например футер), то вам достаточно ему установить свойство clear: both;, как в примере выше, и заниматься дальше своими делами. Это идеальный вариант, поскольку он не требует каких-либо хаков, или дополнительных элементов. Конечно не всё в нашей жизни так гладко и бывают случаи когда такого способа не достаточно. Поэтому необходимо иметь несколько дополнительных способов в своём арсенале.

    Метод пустого div-а. Используется, в буквальном смысле, пустой div.

И, как вы понимаете, каждый из способов используется в различных ситуациях. Возьмём, к примеру, сетку из блочных элементов, отличающихся типами.

Для более лучшего визуального представления было бы неплохо объединить подобные блоки. Например мы хотим, чтобы каждый тип начинался с новой строки, в нашем случае тип элемента определяется цветом. Мы можем использовать метод с overflow или «метод простой очистки», если у каждой группы есть свой элемент-контейнер. Или же мы можем использовать метод пустого div-а между каждой из групп. Три элемента-контейнера, или три пустых div-а, что лучше для вашей задачи — решать вам.

Проблемы с float

Float часто стараются обходить, поскольку работать с ними надо очень аккуратно. Большинство ошибок пришло вместе с IE6. Поскольку всё больше и больше веб-дизайнеров отказываются от поддержки IE6, то вас могут и не волновать эти проблемы. Но для тех, кому не всё равно, вот краткий список.

  • «Выталкивание» (pushdown). Возникает когда элемент внутри float-элемента оказывается шире его (обычно это изображения). Большинство браузеров обработает такие элементы вне float-структуры и вёрстка не будет сломана. IE расширит элемент, чтобы изображение влезло, зачастую это ломает дизайн. На картинке представлен пример, как изображение торчит из основного контента и таким образом «выталкивает» сайд-бар вниз. Самый просто способ избежать этого — это проверить что все ваши изображения подходят по ширине. Можно использовать overflow: hidden;, чтобы обрезать выступающую часть.
  • Двойной внешний отступ. Ошибка проявляющаяся в IE6, в случае если вы устанавливаете внешний отступ в том же направлении, в котором у вас указан float. В этом случае отступ удваивается. Чтобы исправить это, необходимо установить плавающему (float) элементу свойство display: inline;, не беспокойтесь, элемент по прежнему будет блочным.
  • Трёх-пиксельный прыжок (3px Jog). Ошибка, которая проявляется следующим образом: текст, который расположен рядом с float-элементом неожиданно съезжает на 3 пикселя. Чтобы избежать этого, необходимо установить ширину или высоту пострадавшему тексту.
  • В IE7 существует Ошибка нижнего внешнего отступа (Bottom Margin Bug) — возникает когда элемент с установленным свойством float, содержит в себе ещё один float-элемент. В таких случаях, нижний внешний отступ дочернего элемента игнорируется. Для обхода этой проблемы необходимо использовать внутренний отступ родительского элемента, вместо внешнего отступа дочернего.

Альтернативы float

Если вам необходимо обтекание картинки текстом, то альтернатив нет. Но для макета страницы, определённо есть выбор. Существуют очень интересные подходы, в которых комбинируется гибкость float с мощью абсолютного позиционирования. В CSS3 есть, так называемый, Модуль разметки шаблона (Template Layout Module), который в будущем предоставит достойную альтернативу float.

Как передать по modbus float

08.06.2020, 15:36

Как переслать float по modbus?
Пытаюсь прочитать число типа float по modbus длиной в 2 байта, в ответ приходит то, что на.

Modbus RTU (точно float)
Добрый день всем. Возможно мне помогут здесь. Перерыл очень много всего, возможно плохо рыл. .

Передать дробное число по modbus
Здравствуйте. Создал два простых приложения (сервер и клиент) с помощью библиотеки EasyModbus.

Передать в функцию два значения float
Здравствуйте. Например: void Func( Один аргумент. ) < >Как в этот один аргумент.

Не понимает Dictionary DataSet;
Доброго времени суток. Пытаюсь запустить пример по работе с библиотекой. Не понимает конструкцию .

08.06.2020, 18:49 2 08.06.2020, 19:49 [ТС] 3 08.06.2020, 20:41 4
08.06.2020, 20:41
08.06.2020, 20:59 [ТС] 5
08.06.2020, 21:21 6


09.06.2020, 11:33 [ТС] 7
18.07.2020, 15:09 8

напишите пожалуйста подробно, ка Вы сделали обратное преобразование в float?
У меня есть 2 регистра принятых мастером с преобразованым float в байты, как Вы указали вначале тымы.
Эти регистры в программе Ардуино(С++) называются au16data[0] и au16data[1], у них тип uint16_t
Как правильно написать это объединение для моих регистров?

18.07.2020, 15:25 9
18.07.2020, 15:43 10

помогите пожалуйста правильно записать эту конструкцию.

У меня так:
-обьявление переменных

— в терминале выдает нулевое значение перменной t (0.00)

Что я не так сделал?

18.07.2020, 15:54 11

или сразу как-то обрабатывайте.
Единственно, уточняйте порядок байт в принятом числе. Мне доводилось для принятых двух слов обменивать порядок следования и пословно и побайтно. Это есть в документации на прибор. Например, для ОВЕН ТРМ212 после приёма числа потребуется поменять порядок с 0 1 2 3 на 3 2 1 0. Для ВКТ5 я менял только слова: с 0 1 2 3 на 2 3 0 1.
Не знаю только, как это на C показать.

Добавлено через 10 минут

18.07.2020, 16:08 12
18.07.2020, 16:20 13

Он уже учёлся в приведении типов (typecast). Элементы au16data[0] и au16data[1] занимают последовательные ячейки памяти.

Кроме union можно использовать typecast и адресную арифметику, как в примере Как сохранить float в переменной типа char?

Добавлено через 2 минуты
У вас есть эталонные корректные значения au16data и t?
Приведите их.

18.07.2020, 16:29 14
18.07.2020, 18:33 15

это float, только в других языках программирования. Только размер типа float зависит от компилятора, а single — однозначно 32 бита. Плохо знаю C/C++ и путаю ключевые слова из других языков.
Вам главное смысл уловить.

Добавлено через 50 минут
Набрал в gcc для компьютера тестовую программку. Рассмотрел четыре случая:
1. чудной с использованием union
2. принят массив с правильным расположением байт
3. принят массив с обратным расположением слов
4. принят массив с обратным расположением байт

Собственно, я знаю C/C++ также, как и вы, и только что увидел и применил адресную арифметику и приведение типов typecast

Добавлено через 41 минуту
Можно заполнять переменную float по мере приёма слов

18.07.2020, 20:09 16

float это 4 байта
single знаковый число может быть и положительным и отрицательным
unsingle беззнаковый число только положительное
и это приставка для целочисленных типов
может быть (un)signed char размер один байт (un)signed int а здесь зависит от разрядности системы от 2 до 4 байт, в МК обычно 2 байта
в старадавние времена решили int опускать, зачем не знаю, и можно встречать такие записи
signed тоже что и signed int
unsigned long тоже что и insigned long int

18.07.2020, 20:59 17

Не буду спорить. Мои познания в C ближе к суевериям.

У промежуточного топикстартера задача несколько сложнее, чем вывести на печать число float. И ещё, у него задача прямо противоположная самому первому топикстартеру — у того была передача в устройство, а у этого приём из устройства.

Из порта ввода-вывода его программа получает два слова (по 16 бит каждое). Эти два слова ему нужно составить в переменную типа float (размеры совпадают), т.е. сделать typecast.
Примерно эту ситуацию я воспроизвёл в

Может быть на этом беды топикстартера и завершаться. А может случиться, что слова из устройства передаются не в порядке младшее, а потом старшее слово, а наоборот, или даже весь порядок байт обратный. Тогда после завершения приёма (или по мере приёма) нужно переставлять байты или слова уже в составленном числе float.

Поэтому я и привёл примеры преобразования массивов слов в число float.

А также спросил об эталонных значениях принятых слов и их корректной интерпретации. Если у него реальное устройство, то интерпретацию он увидит на дисплее устройства, а значения массива просто выведет контрольной печатью. После этого, немного попереставляв байты, можно разобраться с порядком принимаемых байт.

Потеря точности из Double во Float или «Куда пропадали копейки?»

Преобразование чисел из одного типа в другой обычно ведется таким образом, чтобы не потерять лишних чисел, т.е. из меньшего типа к более вместительному. Но что, если предыдущий разрабочик использовал конвертацию из Double во Float и стали пропадать копейки в отчетах?
В статье приводится изучение конвертации плавающих чисел в Java:

Давайте разберемся, к чему приводит такое преобразование и почему все происходит именно так. Ведь казалось бы, раз используемые в проекте числа далеки от максимальных значений типов float и double, то конвертация его из первого во второй не должна повлечь за собой отрицательных последствий в большинстве случаев.

Любые мысли лучше подкреплять конкретными примерами, поэтому сразу же код, который родился сначала на дрожжах реальных цифр, но потом, под влиянием дискуссии на stackoverflow о подобной конвертации, он превратился в нечто более интригующее.

Способ конвертации

Для демонстрации того, что разнообразные конструкции одинаково конвертируют double во float, добавим разнообразные способы и сравним результаты:

Как можно убедиться, выражения «new Float(d)» и «(float) d» дают одинаковый результат, т.к. первое использует второе:

Если разбираться с функцией Float.parseFloat, то она отсылает нас через несколько других функций до следующей строки:

Которая точно таким же образом конвертирует double-переменную во float.
Таким образом, мы убедились, что, по крайней мере, в openjdk наиболее очевидные пути преобразования double во float сводятся к одной конструкции:

Форматы хранения float и double

В каждом примере мы вызывали функции Long.toBinaryString для Double и Integer.toBinaryString для Float, чтобы продемонстрировать форматы низкоуровневого хранения созданных переменных. Прекрасная статья об этом уже была написана (Что нужно знать про арифметику с плавающей запятой, которая стала отличным переводом английской вики, где хорошо рассказано и про двойную точность), поэтому здесь мы рассмотрим только то, касается округления.
Представленные выше программы вернули следующие результаты:

Тип double занимает 64 бита, а тип float 32, но мы видим 63 и 31 знак — это издержка реализации вывода, который заканчивается, когда остаются только нули. Следовательно, эти числа должны выглядеть так:

Первый бит — это знак числа. Далее 11 (для double) или 8 бит (для float) — экспонента. После — мантисса, которая и играет самую интересную роль. Первое впечатление: просто теряются все числа после 23-его бита при конвертации из double во float. Но давайте сначала попробуем восстановить эти числа, чтобы разобраться во всем по порядку:

  • 1-ые биты 0 => знаки положительные
  • Далее экспоненты: 0100000101002-102310=21

и 100101002-12710=21

Мантиссы: 1.01101011001000101111111000111101011100001010001111012*2 21 — 52 =2974815.779999749

и 1.011010110010001011111112*2 21 — 23 =2974815.75

Таким образом, отсекая от двоичного 0110 1011 0010 0010 1111 1110 0011 1101 0111 0000 1010 0011 1101 из double последние 29 цифр, мы получаем 011 0101 1001 0001 0111 1111 во float, которое дает нам несколько другое число.


Таким образом, конвертация из формата большей точности может привести к нетривиальным потерям достоверности используемых чисел. Что же касается непосредственно Java, то в ней лучше использовать тип Double, т.к. работа с Float чревата конвертациями из Double с потерями. А для хранения денег использовать BigDecimal, чтобы не терять копейки.

Avoiding direct String-to-float conversion by using intermediate doubles.

Предложенные решения

    Хранить деньги в банкахBigDecimal:

Класс Currency по типу:

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

переопределение floatval()

на одном сайте каким-то образом переопределена floatval, так, что она конвертирует число с точкой в число с запятой.

каким образом это происходит? чтобы я мог найти сие место и вернуть в нужное состояние

у меня чего-то эти функции чего-то не определяются
Fatal error: Call to undefined function

вообще, как я понимаю, floatval могли перекрутить с помощью setlocal()
но я не могу найти в коде эту функцию, а главное, в нужном месте просто не могу сделать повторного setlocal() на нужный мне делиметер

Цитата (bars80080 @ 14.10.2011, 16:32 )
на одном сайте каким-то образом переопределена floatval, так, что она конвертирует число с точкой в число с запятой.

это точно? оригинальная floatval() возвращает float, у которого нет понятия символа разделителя. разделитель появляется при конвертации в строку

added later:
bars80080, покажите фрагмент кода, где вызывается floatval

может как-то через апач переопределяеться с помощью подключаемого модуля

хотя не думаю что кто-то на столько изощрен но мало ли, стоит проверить

может речь о том, что floatval воспринимает запятую во входной строке как разделитель? но это странно, насколько я понимаю, floatval не учитывает localeconv[decimal_point] при преобразовании из строки и всегда ожидает точку.
bars80080, попробуйте

имхо должно быть
123456.789 123456.789 123456
123456,789 123456,789 123456

Цитата (baldina @ 14.10.2011, 17:23 )
покажите фрагмент кода, где вызывается floatval

floatval там вызывается везде, поэтому есть сложность с заменой на свою функцию

я провёл тест, загнал такой код

если же вместо floatval просто помножить на единицу, то результат тот же

и этих floatval там по коду — до чёрта. но данные надо вставить в БД, поэтому необходимо их перевести в корректный вид

added later:
уф! помогло

setlocale(LC_NUMERIC, ‘en_US’)
посередь кода — сработало

раньше пытался
setlocale(LC_NUMERIC, ‘en_EN’) — не работало

дело не в floatval, её никто не переопределял, и Вам переопределять не нужно
попробуйте сделать setlocale. её результат зависит от текущих настроек системы (напр, под windows разделитель для текущей локали меняется из панели управления, под linux определения локалей лежат обычно в /usr/share/locale и т.д.)
параметры текущей локали можно проверить при помощи localeconv()

Цитата (bars80080 @ 14.10.2011, 17:51 )
данные надо вставить в БД

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

Запятая, Карл!

Плавающая запятая даёт много преимуществ, но « заплыв» этот полон моментов, требующих понимания и тщательного подхода. Числа с плавающей запятой используются слишком часто, чтобы пренебрегать их глубоким пониманием. Поэтому нужно хорошо разбираться, как представлены числа с плавающей запятой и как работают вычисления с ними.


Число с плавающей запятой представлено в следующем виде:

где m — мантисса ( 23 бита — дробная часть мантиссы и неявно заданный ведущий бит, всегда равный единице, поскольку мантисса хранится в нормализованном виде), e — смещённая экспонента/порядок ( 8 бит). Один бит отводится под знак ( s, бит равен нулю — число положительное, единице — отрицательное).

Тип double полностью аналогичен float , он лишь содержит больше битов мантиссы и порядка.

Рассмотрим какой-нибудь пример. Число 3,5 будет представлено в следующем виде:

Бит знака равен нулю, это говорит о том, что число положительное.

Смещённая экспонента равна 12810 ( 100000002), смещена она на 127, следовательно, в действительности получаем:

e = eshifted − 127 = 128 − 127 = 1.

Нормализованная мантисса равна [1,]110000000000000000000002, то есть 1,7510:

Инвертируем бит знака :

Теперь число стало отрицательным: −3,5.

Рассмотрим несколько исключений. Как представить число 0, если мантисса всегда хранится в нормализованном виде, то есть больше либо равна 1? Решение такое — условимся обозначать 0, приравнивая все биты смещённого порядка и мантиссы нулю:

Ноль бывает и отрицательным:

Плюс и минус бесконечность обозначаются приравниванием всех битов смещённого порядка единице, а битов мантиссы — нулю:

В некоторых случаях результат не определён, для этого есть метка NaN, что значит not a number ( не число). Приравняем все биты смещённого порядка и мантиссы единице ( по правде говоря, достаточно того, чтобы хотя бы один бит мантиссы равнялся единице):

Подводим небольшой итог. Возьмём все возможные сочетания значений всех 32 битов, уберём те варианты, которые зарезервированы для ±∞ и метки NaN, и получим все числа, которые можно хранить в переменной типа float . Их количество очень велико, но пусть это никого не обольщает; из-за особенностей представления, описанных выше, не все числа точно представимы и не все операции выполняются так, как этого можно было бы ожидать.

Более подробно о типах с плавающей запятой можно прочитать в обучающих статьях. Описанный подход к представлению чисел является компромиссом между точностью, диапазоном значений и скоростью выполнения операций с числами с плавающей запятой. Во-первых, число хранится в двоичной форме, но не всякое десятичное число можно представить в виде непериодической дроби в двоичной системе; это одна из причин потери точности ( 0,110 = 0,000(1100)2). Во-вторых, значащих цифр ( цифр мантиссы) не так уж и много: 24 двоичных цифры, или 7,2 десятичных, поэтому придётся много округлять. Но есть и менее очевидные моменты.

Нарушение свойства ассоциативности

Вычислим sin x, разложив эту функцию в ряд Тейлора:

Напишем небольшую функцию, которая будет реализовывать эти вычисления. Тип float вместо double выбран для того, чтобы показать, как быстро накапливается погрешность; никаких дополнительных действий не производится, код исключительно демонстрационный. Целью не является показать, что семи членов ряда недостаточно, цель — показать нарушение свойства ассоциативности операций:

a + ( b + c) ≠ ( a + b) + c,

хотя свойство коммутативности сохраняется:

float Sine( float x )
const int n = 13;
float sine = x ;
bool isNegative = true ;
for ( int i = 3; i ( isNegative ?
— ( pow( x , i) / Factorial(i))
: ( pow( x , i) / Factorial(i)));
isNegative = !isNegative;
return sine;

Теперь напишем аналогичную функцию, но сделаем так, чтобы те же элементы ряда суммировались в обратном порядке.

float SineReversed( float x )
const int n = 13;
float sine = 0;
bool isNegative = false ;
for ( int i = n; i >= 3; i -= 2)
sine += ( isNegative ?
— ( pow( x , i) / Factorial(i))
: ( pow( x , i) / Factorial(i)));
isNegative = !isNegative;
sine += x ;
return sine;

int main()
float sine1 = Sine(3.1415926f);
float sine2 = SineReversed(3.1415926f);

std::cout ( 2.11327e-005), а во втором случае — 0,0000212193 ( 2.12193e-005), совпадают лишь две значащие цифры!

Разгадка проста: у чисел представленного ряда шесть различных ( двоичных) порядков: 1, 2, 1, −1, −4, −8, −12. Когда складываются ( вычитаются) два числа одного порядка или близких порядков, потери точности, как правило, небольшие. Если бы мы складывали огромное число и много маленьких чисел одного порядка, то мы заметили бы, что лучше в плане точности сперва сложить все маленькие числа, а затем уже прибавить большое. Рассмотрим обратный сценарий: сложим большое и первое маленькое число; поскольку порядки значительно различаются, маленькое число будет ( фигурально выражаясь) « раздавлено» большим из-за приведения порядков; получилось новое большое число, не очень точное, но пока ещё достаточно близкое к точному результату; к получившемуся большому числу прибавляем второе маленькое, порядки снова значительно различаются, снова маленькое число оказывается раздавленным, уже две « жертвы». И так далее. Погрешность накопилась достаточно большая.

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

Большие числа

Множество чисел, представимых с помощью float ( и double ), конечно. Из этого, а также из того, что количество разрядов мантиссы весьма ограничено, сразу же следует, что очень большие числа представить не получится; придётся изобретать пути обхода переполнения. Менее очевидным следствием из способа задания числа в виде, описанном выше, является то, что пространство таких чисел не является равномерным. Что это значит?

Возьмём порядок e = 0 и рассмотрим два стоящих подряд числа N1 и N2: у первого мантисса m1 = [1,]000000000000000000000012, у второго — m2 = [1,]000000000000000000000102.

Теперь возьмём порядок e = 127 и снова рассмотрим два стоящих подряд числа: у первого мантисса m3 = [1,]000000000000000000000012, у второго — m4 = [1,]000000000000000000000102.

N3 = 1,701412×10 38 10, N4 = 1,7014122×10 38 10. Разница между ними равна 0,0000002×10 38 10. В рамках этого типа данных нет никакого способа задать некоторое число N, находящееся в интервале между N3 и N4. На секунду, 0,0000002×10 38 — это 20 нониллионов, иначе говоря, двойка и 31 ноль! Маленький шаг для мантиссы и огромный скачок для всего числа.

Получается, что, чем больше порядок числа, тем больше разность между ним и следующим числом, которое представимо в рамках типа float . Каждому порядку соответствует одинаковое количество значений мантиссы, следовательно — одинаковое количество представимых чисел:

порядок 0, значения: 1,0. 1,9999999,
порядок 1, значения: 2,0. 3,9999998,
порядок 2, значения: 4,0. 7,9999995,
порядок 3, значения: 8,0. 15,999999,
порядок 4, значения: 16,0. 31,999998,
порядок 126, значения: 8,507059×10 37 . 1,7014117×10 38 ,
порядок 127, значения: 1,7014118×10 38 . 3,4028235×10 38 .

Каждый из этих диапазонов разбивается на равное количество интервалов. Следовательно, от 1,0 до 1,9999999, от 16,0 до 31,999998, от 1,7014118×10 38 до 3,4028235×10 38 находится одинаковое количество доступных значений — 2 23 − 2 ( поскольку мантисса, за исключением скрытого бита, имеет 23 бита; минус сами границы).

Всё сказанное в равной степени касается отрицательных чисел и чисел с отрицательными порядками.


Когда в программе используются числа с плавающей запятой, необходимо обращать внимание на операции сложения и вычитания из-за нарушения свойства ассоциативности вследствие ограниченной точности типа float ( и double ). Особенно в том случае, когда порядки чисел сильно различаются. Другой проблемой является большой шаг между ближайшими представимыми числами больши ´ х порядков. Что и было показано.

Здесь были освещены только эти два аспекта. Также следует помнить о том, что нельзя непосредственно сравнивать два числа с плавающей запятой ( if ( x == y) ); что у диапазона есть ограничения; что следует использовать логарифм, когда происходят вычисления с использованием огромных чисел. Ну и совсем не следует забывать о бесконечностях и метке NaN. Из экзотики — флаги компилятора, касающиеся точности промежуточных результатов, из простых вещей ( хотя и не менее коварных, чем что-либо упомянутое выше) — особенности приведения типов. В общем, в выражении « вагон и маленькая тележка» эта заметка — даже не тележка, а маленькая горстка. Маленькая, но достаточно важная.

И последнее. Когда требуется точность вычислений ( например, при финансовых расчётах), следует использовать собственные или сторонние классы чисел с фиксированной запятой. Если речь идёт о языке, поддерживающем такие типы, следует использовать их. Таковым, например, является тип decimal в языке C#.

Илон Маск рекомендует:  Шаблон детского сайта HTML, CSS, JS
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL