power, .^

Potencia elemento por elemento

Sintaxis

C = A.^B

C = power(A,B)

Descripción

C = A.^B eleva cada elemento de A a las potencias correspondientes en B. Los tamaños de A y B deben ser los mismos o ser compatibles.

Si los tamaños de A y B son compatibles, los dos arreglos se amplían implícitamente para coincidir el uno con el otro. Por ejemplo, si A o B es un escalar, el escalar se combina con cada elemento del otro arreglo. Además, los vectores con distintas orientaciones (un vector fila y un vector columna) se amplían implícitamente para formar una matriz.

C = power(A,B) es una forma alternativa de ejecutar A.^B, pero se utiliza con poca frecuencia. Permite la sobrecarga de operadores para las clases.

Ejemplos

Elevar al cuadrado cada elemento de un vector

Cree un vector, A, y eleve al cuadrado cada elemento.

A = 1:5;
C = A.^2

C = 1×5

     1     4     9    16    25

Encontrar la inversa de cada elemento de una matriz

Cree una matriz, A, y extraiga la inversa de cada elemento.

A = [1 2 3; 4 5 6; 7 8 9];
C = A.^-1

C = 3×3

    1.0000    0.5000    0.3333
    0.2500    0.2000    0.1667
    0.1429    0.1250    0.1111

Una inversión de los elementos no es igual a la inversa de la matriz, que en su lugar se escribe como A^-1 o inv(A).

Vector fila a potencia de vector columna

Cree un vector fila de 1 por 2 y un vector columna de 3 por 1 y eleve el vector fila a la potencia del vector columna.

a = [2 3];
b = (1:3)';
a.^b

ans = 3×2

     2     3
     4     9
     8    27

El resultado es una matriz de 3 por 2, donde cada elemento (i,j) de la matriz es igual a (j) .^ b(i):

$$a=\left[a_1{a}_2\right],b=\left[\begin{array}{c}{b}_1\\ b_2\\ b_3\end{array}\right],a.ˆb=\left[\begin{array}{cc}{a_1}^{b_1}& {a_2}^{b_1}\\ {a_1}^{b_2}& {a_2}^{b_2}\\ {a_1}^{b_3}& {a_2}^{b_3}\end{array}\right].$$

Encontrar las raíces de un número

Calcule las raíces de -1 a la potencia 1/3.

A = -1;
B = 1/3;
C = A.^B

C = 
0.5000 + 0.8660i

Para A de base negativa y de B no entero, la función power devuelve resultados complejos.

Utilice la función nthroot para obtener las raíces reales.

C = nthroot(A,3)

C = 
-1

Elevar una tabla a la potencia de otra tabla

Desde la versión R2023a

Cree dos tablas y eleve la primera a la potencia de la segunda. Los nombres de las filas (si están presentes en ambas) y los nombres de las variables deben ser iguales, pero no necesitan estar en el mismo orden. Las filas y las variables de la salida están en el mismo orden que la primera entrada.

A = table([1;2],[3;4],VariableNames=["V1","V2"],RowNames=["R1","R2"])

A=2×2 table
          V1    V2
          __    __

    R1    1     3 
    R2    2     4 

B = table([4;2],[3;1],VariableNames=["V2","V1"],RowNames=["R2","R1"])

B=2×2 table
          V2    V1
          __    __

    R2    4     3 
    R1    2     1 

C = A .^ B

C=2×2 table
          V1    V2 
          __    ___

    R1    1       9
    R2    8     256

Argumentos de entrada

A, B — Operandos

escalares | vectores | matrices | arreglos multidimensionales | tablas | horarios

Operandos, especificados como escalares, vectores, matrices, arreglos multidimensionales, tablas u horarios. Las entradas A y B deben ser del mismo tamaño o tener tamaños compatibles (por ejemplo, A es una matriz de M por N y B es un escalar o un vector fila de 1 por N). Para obtener más información, consulte Tamaños de arreglos compatibles para operaciones básicas.

• Los operandos con un tipo de datos enteros no pueden ser complejos.

Las entradas que son tablas u horarios deben satisfacer estas condiciones: (desde R2023a)

• Si una entrada es una tabla o un horario, todas sus variables deben tener tipos de datos que admitan la operación.

• Si solo una entrada es una tabla u horario, la otra entrada debe ser un arreglo lógico o numérico.

• Si ambas entradas son tablas u horarios:

  • Ambas entradas deben tener el mismo tamaño, o bien una de ellas debe ser una tabla de una fila.

  • Ambas entradas deben tener variables con los mismos nombres. Sin embargo, las variables de cada entrada pueden estar en un orden diferente.

  • Si ambas entradas son tablas y ambas tienen nombres de filas, los nombres de sus filas deben ser los mismos. Sin embargo, los nombres de las filas de cada entrada pueden estar en un orden diferente.

  • Si ambas entradas son horarios, las horas de sus filas deben ser iguales. Sin embargo, las horas de las filas de cada entrada pueden estar en un orden diferente.

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char | table | timetable
Soporte de números complejos: Sí

Más acerca de

Cumplimiento con IEEE

En las entradas reales, power tiene comportamientos que difieren de los recomendados en el estándar IEEE^®-754.

	MATLAB®	IEEE
power(1,NaN)	NaN	1
power(NaN,0)	NaN	1

Sugerencias

• Utilizar times o .* para multiplicaciones repetidas puede ser más rápido que usar power o .^ con exponentes enteros. Sin embargo, los errores de redondeo son mayores con las multiplicaciones repetidas porque los errores se acumulan. Esto es especialmente importante para el tipo de datos double. Para los tipos de datos en los que los errores de redondeo no son un problema, como int64, puede utilizar times. Por ejemplo, si define x = int64(randi([1, 10], 10000, 1));, la operación y = x.*x.*x; es más rápida que y = x.^3;.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

La función power es totalmente compatible con los arreglos altos. Para obtener más información, consulte Arreglos altos.

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• Cuando tanto X como Y son reales, pero power(X,Y) o X .^ Y son complejos, la simulación produce un error y el código generado devuelve NaN. Para obtener el resultado complejo correcto, convierta el valor complejo X usando complex(X). Por ejemplo, power(complex(X),Y) o complex(X).^Y.

• La generación de código no es compatible con entradas de matrices dispersas en esta función.

Generación de código de GPU

Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Notas y limitaciones de uso:

• Cuando tanto X como Y son reales, pero power(X,Y) o X .^ Y son complejos, la simulación produce un error y el código generado devuelve NaN. Para obtener el resultado complejo correcto, convierta el valor complejo X usando complex(X). Por ejemplo, power(complex(X),Y) o complex(X).^Y.

• La generación de código no es compatible con entradas de matrices dispersas en esta función.

Generación de código HDL

Genere código VHDL, Verilog y SystemVerilog para diseños FPGA y ASIC mediante HDL Coder™.

Ambas entradas deben ser escalares y la entrada del exponente, k, debe ser un entero.

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

La función power es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en entornos basados en subprocesos.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función power es compatible con entradas de arreglos de GPU con estas notas y limitaciones de uso:

• Si la base A o el exponente B son dispersos, B debe ser un escalar.

• Si la salida de la función que se ejecuta en la GPU puede ser compleja, debe especificar explícitamente sus argumentos de entrada como complejos. Para obtener más información, consulte Work with Complex Numbers on a GPU (Parallel Computing Toolbox).

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

La función power es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

R2026a: Rendimiento mejorado con exponentes enteros

La función power (.^) muestra un rendimiento mejorado al calcular potencias elemento por elemento con exponentes enteros. Por ejemplo, este código eleva cada elemento en un arreglo de 5000 por 5000 a la potencia de 3. El código es aproximadamente 3,8 veces más rápido que en la versión anterior.

function t = timingPower
x = rand(5000);
y = @() x.^3;
t = timeit(y);
end

Los tiempos de ejecución aproximados son:

R2025b: 0,80 s

R2026a: 0,21 s

El código se cronometró en un sistema de prueba Windows^® 11 y procesador AMD EPYC™ 74F3 de 24 núcleos @ 3,19 GHz llamando a la función timingPower.

Consideraciones sobre compatibilidad

Esta mejora del rendimiento se debe a los cambios de código que también generan como resultado un comportamiento de redondeo ligeramente diferente en doble precisión, lo que conlleva resultados más precisos. Por ejemplo, este código ahora devuelve un resultado que es más preciso hasta el 15.º dígito después del separador decimal en notación científica larga.

format longE
y = 0.4543.^3

y =
     9.376229100700000e-02

Anteriormente, el mismo código devolvía este resultado.

format longE
y = 0.4543.^3

y =
     9.376229100699998e-02

Tenga en cuenta que MATLAB convierte una entrada de número decimal, como 0.4543, al valor binario de doble precisión representable más cercano, que es posible que no sea exactamente igual a la entrada decimal original. Por este motivo, aunque el operador .^ ahora es más preciso en doble precisión, el resultado puede ser distinto a un cálculo realizado utilizando la representación exacta de los operandos.

R2026a: La combinación de operadores de exponenciación con operadores unarios o negaciones lógicas sin paréntesis no será compatible en una versión futura

Cuando especifique una secuencia de operadores de exponenciación combinada con operadores unarios o negaciones lógicas en los exponentes, deberá utilizar paréntesis para especificar de manera explícita el orden de las operaciones. Omitir paréntesis en operaciones que incluyen ^-, .^-, ^+, .^+, ^~ o .^~ cuando están en cadena con otros operadores de exponenciación generará un error en una versión futura.

Por ejemplo, el resultado de una operación como y = 4.^-3.^-2 depende del orden en el que se lleva a cabo la exponenciación y la negación. Por este motivo, utilice paréntesis para especificar de manera explícita el orden previsto de las operaciones. Por ejemplo:

y = (4.^(-3)).^(-2)

y =
    4096

y = 4.^(-(3.^(-2)))

y =
    0.8572

y = 4.^((-3).^(-2))

y =
    1.1665

R2023a: Realizar operaciones directamente en tablas y horarios

El operador power admite operaciones directamente en las tablas y en los horarios sin indexar para acceder a sus variables. Todas las variables deben tener tipos de datos que admitan la operación. Para obtener más información, consulte Direct Calculations on Tables and Timetables.

R2016b: El cambio en la ampliación implícita afecta a los argumentos para operadores

A partir de la versión R2016b con la incorporación de la ampliación implícita, algunas combinaciones de argumentos para operaciones básicas que anteriormente devolvían errores ahora generan resultados. Por ejemplo, anteriormente no podía añadir un vector fila y columna, pero ahora dichos operandos están disponibles para que se añadan. En otras palabras, una expresión como [1 2] + [1; 2] anteriormente devolvía un error de falta de coincidencia de tamaños, pero ahora se ejecuta.

Si su código utiliza operadores elemento por elemento y se basa en los errores que MATLAB devolvía anteriormente para tamaños que no coincidían, especialmente dentro de un bloque try/catch, es posible que su código deje de detectar esos errores.

Para obtener más información sobre los tamaños de entrada necesarios para operaciones básicas con arreglos, consulte Tamaños de arreglos compatibles para operaciones básicas.

Consulte también

realpow | mpower | nthroot

Temas

• Operaciones con matrices y operaciones con arreglos
• Precedencia de operadores
• Operadores y caracteres especiales de MATLAB