Orden de operaciones aritméticas

Un problema que apareció en Internet a principios de 2011 es: "¿Cuál es el valor de 48/2 (9 + 3)?" 

Dependiendo de si se interpreta la expresión como (48/2) (9 + 3) o como 48 / (2 (9 + 3)) se obtiene 288 o 2. No existe una convención estándar en cuanto a cuál de estas dos formas la expresión debe interpretarse, por lo que, de hecho, 48/2 (9 + 3) es ambiguo. 

En general, para cualquier expresión de la forma a / bc es necesario insertar paréntesis para mostrar si significa (a / b) c o a / (bc). Bajo la convención algebraica estándar, expresiones como ab + c son inequívocas: esa expresión significa solo (ab) + c; y de manera similar, a + bc significa solo a + (bc). 

La convención es que cuando no se usan paréntesis para mostrar lo contrario, la multiplicación precede a la suma. Para expresiones como a − b + c se dice que cuando se tiene una secuencia de sumas y restas se trabaja de izquierda a derecha. 

Probablemente otra razón por la que no existe una convención fija para el orden de multiplicación y división, como la hay para la suma y la resta, es que la gente con frecuencia hace cálculos que implican sumar y restar largas cadenas de números y los números de multiplicaciones y divisiones que vienen en los cálculos diarios tiende a ser menor; por lo que hay menos necesidad de una convención y ninguna ha evolucionado. 

En muchas escuelas de hoy, a los estudiantes se les enseña el orden de las operaciones: paréntesis, exponentes, multiplicación, división, suma, resta.

La aritmética de Trachtenberg

Así como Viktor Emil Frankl desarrollo la logoterapia para superar los rigores de los campos de concentración Nazi, Jakow Trachtenberg ocupo su mente en desarrollar un sistema de aritmética mental al verse en la misma situación.

El sistema Trachtenberg de rápido cálculo mental, similar a las matemáticas Védicas, consiste en un conjunto de patrones para realizar operaciones aritméticas. Los algoritmos más importantes son multiplicación,división, y adición. El método también incluye algoritmos especializados para realizar multiplicaciones por números entre 5 y 13.

Multiplicación por 11

Abusando de la notación

(11)a = 11Σa_i10ⁱ =

a_n10ⁿ⁺¹ + [Σ_j=0^n-1(a_j+a_j+1)10^j ]+ a₀

Multiplicación por 12

(12)a = 12Σa_i10ⁱ =

a_n10ⁿ⁺¹ + [Σ_j=0^n-1 (a_j+2a_j+1)10^j ]+ 2a₀

Multiplicación por 6

Definiendo

b_j = a_j/2, donde / denota división entera

c_j = a_j mod 2

tenemos

a_j = 2b_j + c_j

(6)a = (10/2)Σa_i10ⁱ  + Σa_i10ⁱ =

Σb_i10ⁱ⁺¹ + Σ(a_i + 5c_i)10ⁱ

b_n10ⁿ⁺¹ + [Σ_j=1ⁿ(a_j + 5c_j + b_j-1)10^j ]+ (a₀ + 5c₀)

Expresando el algoritmo en python:

def x6(number):
	previous = 0
	result = 0
	power_of_10 = 1
	while (number):
		digit = number%10
		odd_term = 5 if digit%2 else 0
		result = 
                (digit + odd_term + previous ) * 
		power_of_10 + result
		previous = digit//2
		power_of_10 *= 10
		number = number // 10
	result = previous * power_of_10 + result
	return result

Multiplicación por 7

De manera similar al caso anterior:

a_j = 2b_j + c_j

(7)a = (10/2)Σa_i10ⁱ  + Σ2a_i10ⁱ =

Σb_i10ⁱ⁺¹ + Σ(2a_i + 5c_i)10ⁱ

b_n10ⁿ⁺¹ + [Σ_j=1ⁿ(2a_j + 5c_j + b_j-1)10^j ]+ (a₀ + 5c₀)

Expresando el algoritmo en python:

def x7(number):
	previous = 0
	result = 0
	power_of_10 = 1
	while (number):
		digit = number%10
		odd_term = 5 if digit%2 else 0
		result = 
                (2*digit + odd_term + previous ) * 
		power_of_10 + result
		previous = digit//2
		power_of_10 *= 10
		number = number // 10
	result = previous * power_of_10 + result
	return result

Multiplicación por 5

De manera similar al caso anterior:

a_j = 2b_j + c_j

(5)a = (10/2)Σa_i10ⁱ   =

Σb_i10ⁱ⁺¹ + Σ(5c_i)10ⁱ

b_n 10ⁿ⁺¹ + [Σ_j=1ⁿ(5c_j + b_j-1)10^j ]+ (5c₀)

Expresando el algoritmo en python:

def x5(number):
	previous = 0
	result = 0
	power_of_10 = 1
	while (number):
		digit = number%10
		odd_term = 5 if digit%2 else 0
		result = 
                (odd_term + previous ) * 
		power_of_10 + result
		previous = digit//2
		power_of_10 *= 10
		number = number // 10
	result = previous * power_of_10 + result
	return result

Multiplicación por 9

Definiendo

b = 10ⁿ⁺¹ - Σ_j=0ⁿa_j , o sea el complemento a 10 de a

tenemos

(9)a = 10a –a =

10a –a + b – b =

10a + b - 10ⁿ⁺¹ =

(a_n – 1)10ⁿ⁺¹ + [Σ_j=1ⁿ(b_j + a_j-1)10^j ]+ (b₀ )

Expresando el algoritmo en python:

def x9(number):
	previous = number%10
	result = 10 - previous
	power_of_10 = 10
	number = number // 10
	while (number):
		digit = number%10
		result = 
                (9 - digit + previous ) * 
                power_of_10 + result
		previous = digit
		power_of_10 *= 10
		number = number // 10
	result = 
        (previous-1) * power_of_10 + 
        result
	return result

Multiplicación por 8

Definiendo

b = 10ⁿ⁺¹ - Σ_j=0ⁿa_j , o sea el complemento a 10 de a

tenemos

(8)a = 10a –2a =

10a –2a +2 b – 2b =

10a + 2b – (2)10ⁿ⁺¹ =

(a_n – 2)10ⁿ⁺¹ + [Σ_j=1ⁿ(2b_j + a_j-1)10^j ]+ (2b₀ )

Expresando el algoritmo en python:

def x8(number):
	previous = number%10
	result = 2*(10 - previous)
	power_of_10 = 10
	number = number // 10
	while (number):
		digit = number%10
		result = 
		(2*(9 - digit) + previous ) * 
                power_of_10 + result
		previous = digit
		power_of_10 *= 10
		number = number // 10
	result = 
        (previous-2) * 
        power_of_10 + result
	return result

Multiplicación por 3 y por 4

Los algoritmos para multiplicar por 3 y por 4 combinan las ideas usadas en la multiplicación por 5 y por 9.

Definiendo

b = 10ⁿ⁺¹ - Σ_j=0ⁿa_j , o sea el complemento a 10 de a

a_i = 2c_i + d_i, donde

c_i = a_i/2

d_i = a_i mod 2

tenemos

(4)a = 5a –a =

10c + 5d + b - 10n+1

(3)a = 5a –2a =

10c + + 5d + 2b – (2)10ⁿ⁺¹

Expresando los algoritmos en python:

def x3(number):
	digit = number%10
	result = 2*(10 - digit)
	if digit % 2:
		result += 5
	previous = digit // 2
	power_of_10 = 10
	number = number // 10
	while (number):
		digit = number%10
		odd_term = 5 if digit%2 else 0
		result +=(2*(9 - digit) + odd_term + previous ) * power_of_10
		previous = digit//2
		power_of_10 *= 10
		number = number // 10
	result = (previous-2) * power_of_10 + result
	return result

def x4(number):
	digit = number%10
	result = (10 - digit)
	if digit % 2:
		result += 5
	previous = digit // 2
	power_of_10 = 10
	number = number // 10
	while (number):
		digit = number%10
		odd_term = 5 if digit%2 else 0
		result +=((9 - digit) + odd_term + previous ) * power_of_10
		previous = digit//2
		power_of_10 *= 10
		number = number // 10
	result = (previous-1) * power_of_10 + result
	return result	

Referencias

• The Trachtenberg Speed System of Basic Mathematics



• http://en.wikipedia.org/wiki/Trachtenberg_system