Cómo convertir un número entero para flotar en Delphi?

Question

Cómo convertir un número entero para flotar en Delphi?

E.g int_h: = int_var/1.5 * int_var;

Answer 1

i * 1.0 debería convertirlo a un número de punto flotante. Cualquier cálculo que implique números de punto flotante de cualquier tipo se convierte implícitamente a extendend y luego se convierte implícitamente al tipo de resultado deseado en la asignación. A diferencia de C/C++, todos los cálculos se realizan en Extended (flotante de 80 bits, el formato interno de la unidad de punto flotante x87) y se vuelven a convertir más tarde.

real (i) podría funcionar también.

Answer 2

que puede hacer:

myFloat := myInteger; 

Answer 3

3 formas posibles, dependiendo del tipo de expresiones que tiene.

var 
    Float: Double; 
    Int1: Integer; 
    Int2: Integer; 
begin 
    Int1 := 925; 
    Int2 := 21; 
    Float := Int1; // simple form: assign it 
    Writeln(Float); 
    Float := Int2/Int1; // floating point division: assign it 
    Writeln(Float); 
    Float := (1.0 * Int2) * Int1; // integer operator: multiply by 1.0 and add parenthesis 
    Writeln(Float); 
end. 

Salida:

9.25000000000000E+0002 
2.27027027027027E-0002 
1.94250000000000E+0004 

Answer 4

Entero flotar

No hay necesidad de echar nada, sólo asignar

Float1 := Integer1; 

Su pregunta parece ser flotante a un entero

Dos opciones

Integer1 := Trunc(Float1); //truncate 

o

Integer1 := Round(Float1); //Round 

Answer 5

tengo esto dos (tengo más, pero, por ejemplo, sería suficiente) oveloaded funciones:

interface 
    function MyFunc(Value:Integer):Integer;overload; 
    function MyFunc(Value:Double):Double;overload; 
implementation 
    function MyFunc(Value:Integer):Integer; 
    begin 
     MyFunc:=Math.Ceil({Do some extra complicated Math calcs} 
          * 
          MyFunc({¿How to Type Cast as Double?} Value) 
         ); 
    end; 
    function MyFunc(Value:Double):Double; 
    begin 
     MyFunc:={Do some Math calcs with Value}; 
    end; 

¿Cómo puede en Typecast de números enteros y Doble ? Odio poner '(1.0 * Valor)' o '(0.0 + Valor)' que usa menos tiempo de CPU, debe existir de alguna otra forma para hacerlo.

CUIDADO: quiero decir encasillado en esa llamada !!! CUIDADO: la llamada está en una función sobrecargada, una llama a la otra

Espero que alguien encuentre el camino, porque poner'MyFunc ((Doble) Valor) 'dice encasillado no válido ... por qué demonios lanza un número entero un doble no es posible ??? un doble puede almacenar un entero ... y más, al asignarlo lo lanza directamente ...'MyVarOfTypeDouble: = MyvarOfTypeInteger; 'funciona perfecto.

El problema viene con funciones sobrecargadas ... no sé que quiero llamar a doble versión de un ... es por eso que se necesita un yeso ...

En otras palabras ... esto trabajar como un encanto:

interface 
    function MyFunc_Integer(Value:Integer):Integer; 
    function MyFunc_Double(Value:Double):Double; 
implementation 
    function MyFunc_Integer(Value:Integer):Integer; 
    begin 
     MyFunc_Integer:=Math.Ceil({Do some extra complicated Math calcs} 
            * 
            MyFunc_Double(Value) 
           ); 
    end; 
    function MyFunc_Double(Value:Double):Double; 
    begin 
     MyFunc_Double:={Do some Math calcs with Value}; 
    end; 

Véase, si los nombres de las funciones son diferentes, no hay necesidad de echar ... hasta que encontré una solución mejor que debe tener miedo de que voy a utilizar '(0.0 + Valor)' donde debería funcionar (pero no lo hace) '(Double) value', cuando Value es de tipo Integer.

Así que mi respuesta es ...en lugar de poner código '(Doble) SomethingOfTypeInteger' (que debería funcionar pero no le gusta al compilador) ... poner este otro código '(0.0 + SomethingOfTypeInteger)', recomiendo no usar '(1.0 * SomethingOfTypeInteger)' ya que es mucho menos eficiente ...

Nunca jamás pensar en la creación de una función como ésta (que también es peor que 1,0 * Valor):

function ConvetIntegerToDouble(Value:Integer):Double; 
begin 
    ConvetIntegerToDouble:=Value; 
end; 

Esa función cumple grande ... pero lleva mucho , mucho más tiempo que poner '0.0 + valor '.

Ahora a muy, muy ... Un montón de gente muy inteligente ... ver esto (muy feo) código:

interface 
     function MyFunc(Value:Integer):Integer;overload; 
     function MyFunc(Value:Real48):Real48;overload; 
     function MyFunc(Value:Real):Real;overload; 
     function MyFunc(Value:Double):Double;overload; 
     procedure CanYouGuess; 
    implementation 
    var 
     MyVarOfTypeDouble:Double; 
     function MyFunc(Value:Integer):Integer; 
     begin 
      MyFunc:=Round(MyFunc(1.0+Value)); 
     end; 
     function MyFunc(Value:Real48):Real48; 
     begin 
      MyFunc:=MyFunc(2.0+Value); 
     end; 
     function MyFunc(Value:Real):Real; 
     begin 
      MyFunc:=MyFunc(4.0+Value); 
     end; 
     function MyFunc(Value:Double):Double; 
     begin 
      MyFunc:=(8.0+Value); 
     end; 
     procedure CanYouGuess; 
     var 
      MyVarOfTypeReal48:Real48; 
      MyVarOfTypeReal:Real; 
     begin 
      MyVarOfTypeDouble:=MyFunc(0); // What value will be on MyVarOfTypeDouble? 
      MyVarOfTypeReal48:=0; 
      MyVarOfTypeDouble:=MyFunc(MyVarOfTypeReal48); // What value will be on MyVarOfTypeDouble? 
      MyVarOfTypeReal:=0; 
      MyVarOfTypeDouble:=MyFunc(MyVarOfTypeReal); // What value will be on MyVarOfTypeDouble? 
      MyVarOfTypeDouble:=MyFunc(0.0); // What value will be on MyVarOfTypeDouble? 
     end; 

Ahora tratar de adivinar los valores ... la lectura de códigos no está claro qué las llamadas deben ir ... paso un entero, luego dentro de la versión de Envelope oveload ... ¿cuál se llama ... Real48 sobrecargado o Real one o Double one? ... lo mismo aplica para pasar un Real48 y también pasar un Real ...

El compilador no encontró ningún error ... pero no sé cuál (si solo uno) se llamará ... sin seguimiento, ¡¡¡por supuesto!!! ¿puedes?

Para este tipo de situaciones es donde conversión explícita Sería muy bueno para trabajar ...

Tenga en cuenta que puse 1.0+, 2.0+, 4.0+, ... 8.0+ potencias de 2 ... por lo que cualquier suma de alguno o algunos de ellos se puede ver ... si resoult es 15 ... todos ellos se han ejecutado ... si 3 solo 1.0 y 2.0, etc ... modo binario !!! como bits de peso, etc ... es solo para mostrar cómo un código puede ser demasiado complicado ... solo porque una función sobrecargada debe tener parámetros diferentes ...

Esto no está permitido, ya que el compilador no sabe qué una para llamar:

interface 
     function MyFunc(Value:Double):Integer;overload; 
     function MyFunc(Value:Double):Real48;overload; 
     function MyFunc(Value:Double):Real;overload; 
     function MyFunc(Value:Double):Double;overload; 

Sí, es un compilador bastante estúpida ... se puede compilar sólo en los casos en que se utiliza en una MyFunc assigment .... sí este código:

MyVarOfTypeReal48:=MyFunc(1); // It can know return value must be Real48, so call that one... but compiler is not so Intelligent 

En tales casos, se puede saber a cuál llamar ... el problema es con:

MyVarOfTypeInteger:=Round(5*MyFunc(1)+MyFunc(2)*1.3); // This is problematic, first one could be understod as Integer version, second one as ... as what? Real, Real48 or Double? not possible to know... that is why compiler does not like such overloaded (with same arguments). 

Espero que esto ayude!