número al cuadrado en la programación

Question

Sé que esta es probablemente una pregunta muy simple, pero ¿cómo podría hacer algo como n en un lenguaje de programación?

¿Es n * n? ¿O hay otra manera?

Answer 1

n * n es la manera más fácil.

Para lenguajes que soportan el operador de exponenciación (** en este ejemplo), también se puede hacer n ** 2

lo contrario, podría utilizar una biblioteca matemática para llamar a una función como pow(n, 2) pero eso es algo excesivo por el simple hecho cuadrar una número.

Answer 2

n * n casi siempre funcionarán - los casos de par en que no funcionarán están en los lenguajes de prefijo (Lisp, Scheme, y co.) O en los idiomas de posfijo (Forth, Factor, bc, dc); pero obviamente puedes escribir (* n n) o n n* respectivamente.

También se producirá un error cuando hay un caso de desbordamiento:

#include <limits.h> 
#include <stdio.h> 
int main() 
{ 
    volatile int x = INT_MAX; 
    printf("INT_MAX squared: %d\n", x * x); 
    return 0; 
} 

Tiré el cuantificador volatile allí sólo para señalar que esto puede ser compilado con -Wall y no plantea ninguna advertencia, pero en mi 32 equipo bit que esto dice que INT_MAX cuadrado es 1.

Dependiendo del idioma, es posible que tenga una función tal como powerpow(n, 2) in C, o math.pow(n, 2) en Python ... Desde aquellos power funciones emitidos a flotante números de punto, son más útiles en los casos en que es posible el desbordamiento.

Answer 3

Hay muchos lenguajes de programación, cada uno con su propia forma de expresar operaciones matemáticas.

Entre los más comunes serán:

x*x 

pow(x,2) 

x^2 

x ** 2 

square(x) 

(* x x) 

Si especifica un idioma específico, podemos darle una mayor orientación.

Answer 4

Si n es un número entero: p:

int res=0; 
for(int i=0; i<n; i++) 
    res+=n; //res=n+n+...+n=n*n 

Para números enteros positivos que esté utilizando la recursión:

int square(int n){ 
if (n>1) 
    return square(n-1)+(n-1)+n; 
else 
    return 1; 
} 

Calcular usando matriz de asignación (extremadamente sub-óptimo):

#include <iostream> 
using namespace std; 

int heapSquare(int n){ 
    return sizeof(char[n][n]); 
} 

int main(){ 
for(int i=1; i<=10; i++) 
    cout << heapSquare(i) << endl; 
return 0; 
} 

Usando el cambio de bit (multiplicación del antiguo Egipto):

int sqr(int x){ 
    int i=0; 
    int result = 0; 
    for (;i<32;i++) 
     if (x>>i & 0x1) 
     result+=x << i; 
    return result; 
} 

Asamblea:

int x = 10; 
    _asm_ __volatile__("imul %%eax,%%eax" 
        :"=a"(x) 
        :"a"(x) 
        ); 
    printf("x*x=%d\n", x); 

Answer 5

Siempre utilice la multiplicación de la lengua, a menos que el lenguaje tiene una función explícita square. Evite específicamente el uso de la función pow proporcionada por la mayoría de las bibliotecas matemáticas.La multiplicación será (excepto en las circunstancias más escandalosas) siempre más rápida y, si su plataforma cumple con la especificación IEEE-754, que es lo que hacen la mayoría de las plataformas, ofrecerá un resultado redondeado correctamente. En muchos idiomas, no existe un estándar que rija la precisión de la función pow. En general, dará un resultado de alta calidad para un caso tan simple (muchas implementaciones de bibliotecas cuadrarán casos especiales para salvar a los programadores de ellos mismos), pero no desea depender de esto [1].

veo una tremenda cantidad de código C/C++ donde los desarrolladores han escrito:

double result = pow(someComplicatedExpression, 2); 

presumiblemente para evitar tener que escribir tan complicado expresión dos veces o porque piensan que de alguna manera se ralentizará su código para utilizar una variable temporal . No lo hará. Los compiladores son muy buenos para optimizar este tipo de cosas. En su lugar, escriba:

const double myTemporaryVariable = someComplicatedExpression; 
double result = myTemporaryVariable * myTemporaryVariable; 

En resumen: use la multiplicación. Siempre será al menos tan rápido y al menos tan preciso como cualquier otra cosa que puedas hacer [2].

1) Los compiladores recientes en plataformas convencionales pueden optimizar pow(x,2) en x*x cuando la semántica del lenguaje lo permita. Sin embargo, no todos los compiladores hacen esto en todas las configuraciones de optimización, que es una receta para errores de redondeo difíciles de depurar. Mejor no depender de eso.

2) Para tipos básicos. Si realmente desea participar, si la multiplicación debe implementarse en el software para el tipo con el que está trabajando, existen formas de realizar una operación de cuadratura que es más rápida que la multiplicación. Sin embargo, casi nunca se encontrará en una situación donde esto importe.