Saturday, October 12, 2024

Casio fx-CG 50: Centroid of a 2D spaces

Casio fx-CG 50: Centroid of a 2D spaces





The program CENTROID calculates the center point for an area covered by:


y(x) ≥ 0, x ≥ lower limit, x ≤ upper limit


The center point is calculated by:


x-center = ∫( x * y(x) dx, x = lower limit, x = upper limit) / A

y-center = ∫(1 / 2 * y(x)^2 dx, x = lower limit, x = upper limit) / A

where A = ∫( y(x) dx, x = lower limit, x = upper limit)



Casio fx-CG 50 Program Code: CENTROID


Here is the code, which includes a graphic representation of y(x) and the location of the centroid. In this code, the Y is bold and it comes from the VARS menu. Do not merely use ALPHA+Y. For calculators with monochrome screens, such as the fx-9750G/fx-9860G series, leave out the color commands (Black, Blue, Red). The program assumes that there no preset plots or more than one function to be plotted.


This program works best for functions y(x) ≥ 0 for x ∈ [lower limit, upper limit].




Here is a text-only version:






Examples


Example 1: y = x^2 , lower limit = 0, upper limit = 1

X-Center = 3 / 4 = 0.75

Y-Center = 3 / 10 = 0.3




Example 2: y = 2 * cos( x / 2 ), lower limit = 0, upper limit = π

X-Center ≈ 1.141592654

Y-Center ≈ 0.7853981634




Example 3: y = 3, lower limit = 1, upper limit = 5

X-Center = 3

Y-Center = 1.5




Example 4: y = -4 * x^2 + 2 * x + 6, lower limit = -0.5, upper limit = 1

X-Center = 1 / 4

Y-Center = 307 / 110




Eddie


All original content copyright, © 2011-2024. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.

Saturday, October 5, 2024

Sum of Sequential Integers (featuring Swiss Micros DM32)

 Sum of Sequential Integers (featuring Swiss Micros DM32)


What is the sum of the following:

100 + 101 + 102 + 103 + 104 + 105 + … + 997 + 998 + 999?


It’s doable on a calculator, but going straight forward will require a lot of keystrokes (unless you have access to the sigma function (Σ)).


Note that:

100 + 101 + 102 + 103 + 104 + 105 + … + 997 + 998 + 999

= 100 + (100 + 1) + (100 + 2) + (100 + 3) + (100 + 4) + …. + (100 + 897) + (100 + 898) + (100 + 899)

= (100 + 0) + (100 + 1) + (100 + 2) + (100 + 3) + (100 + 4) + …. + (100 + 897) + (100 + 898) + (100 + 899)


Notice the sum starts with a base, 100. The sequence goes for 900 terms in the form of 100+n where n = 0 to 899. Let’s look at a general case.


Let x be a base integer, and S be the sum as:


S = (x + 0) + (x + 1) + (x + 2) + (x + 3) + …. + (x + n)


Rearranging the terms leads us to:


S = (x + x + x + x + … + x) + (0 + 1 + 2 + 3 + 4 + … + n)

There are n + 1 pairs:

S = (x * (n + 1)) + (0 + 1 + 2 + 3 + 4 + … + n)

S = (x * (n + 1)) + (1 + 2 + 3 + 4 + … + n)


The sum of Σ( k, k = 1 to k = n) = 1 + 2 + 3 + 4 + … + n = n * (n + 1) / 2


Then:

S = (x * (n + 1)) + n * (n + 1) / 2


Let’s look at some specific examples:


n = 1

S = (x + 0) + (x + 1)

S = (x + x) + (0 +1)

S = 2 * x + 1


n = 2

S = (x + 0) + (x + 1) + (x + 2)

S = (x + x + x) + (0 + 1 + 2)

S = 3 * x + 3


2 * 3 / 2 = 3


n = 3

S = (x + 0) + (x + 1) + (x + 2) + (x + 3)

S = (x + x + x + x) + (0 + 1 + 2 + 3)

S = 4 * x + 6


3 * 4 / 2 = 6


S = 500 + 501 +502 + 503

S = (500 + 0) + (500 + 1) + (500 + 2) + (500 + 3)

S = (500 + 500 + 500 + 500) + (0 + 1 + 2 + 3)

S = ((3 + 1) * 500) + (3 * 4 / 2)

S = 2000 + 6

S = 2006



S = 250 + 251 + 252 + 253 + … + 269 + 270

Base = 250

n = 270 – 250 = 20


Then:

S = 250 * (20 + 1) + 20 * 21 / 2

S = 5460


Let’s go our original problem:

S = 100 + 101 + 102 + 103 + 104 + 105 + … + 997 + 998 + 999

Base = 100

n = 999 -100 = 899

Then:

S = 100 * (899 + 1) + 899 * 900 / 2

S = 90000 + 404550

S = 494550



The program code calculates the sum:


Swiss Micros DM32 Program (also HP 32SII)


S01 LBL S

S02 INPUT X

S03 INPUT N

S04 RCL N

S05 1

S06 +

S07 RCL× N

S08 RCL N

S09 1

S10 RCL+ N

S11 ×

S12 2

S13 ÷

S14 +

S15 RTN


Eddie


All original content copyright, © 2011-2024. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.


Sunday, September 29, 2024

TI-30Xa Algorithm: Synthetic Division

TI-30Xa Algorithm:  Synthetic Division



Introduction


Synthetic division is a fairly simple division algorithm that divides a polynomial by the nominal (x-a):


p(x) / (x  - c) where


p(x) = a_n * x^n + a_n-1 * x^(n-1) + a_n-2 * x^(n - 2) + … + a_1 * x + a_0

c = a numerical constant


the result, q(x), is a polynomial of order n-1:


q(x) = b_n-1 * x^(n-1) + b_n-2 * x^(n - 2) + … + b_1 * x + b_0 + b_r / (x - c)

b_r = remainder term


where 


b_n-1 = a_n

b_i-1 = b_i  * c + a_i for i = n-2 down to r (“-1”, see the example below)  


For example, for the polynomial:


p(x) = a3 * x^3 + a2 * x^2 + a1 * x + a0


q(x) = p(x) / (x - c) 


p(x) has the order n = 3, so q(x) will have the order n = 3 - 1 = 2:


q(x) = b2 * x^2 + b1 * x + b0 + br / (x - c)


b2 = a3

b1 = b2 * c + a2

b0 = b1 * c + a1

br = b0 * c + a0  (the algorithm stops, this is the remainder term)


If br = 0, the x - c divides p(x) evenly, and x = c is a root of p(x).  


Note: for any “missing” terms, fill the term with 0.   

Example:  x^3 + 4 * x - 5 becomes x^3 + 0 * x^2 + 4 * x - 5.



Calculator Algorithm


  1. Store c in one of the memory registers 1, 2, or 3.   We’ll call this memory register m for the purpose of the blog.

  2. Note the first coefficient of q(x):  a_n

  3. Compute the rest of the coefficients as follows:  [ × ] [ RCL ] m [ + ] a_ni [ = ]



Examples


Remember:  m is memory register 1, 2, or 3, your choice.  


Example 1:  (21 * x^2 + 42 * x + 144) / (x - 12) 


c = 12

a2 = 21

a1 = 42

a0 = 144


b1 = a2 = 21


12 [ STO ] m

Enter 21


b0:

[ × ] [ RCL ] m [ + ] 42 [ = ]

Result:  294


br:

[ × ] [ RCL ] m [ + ] 144 [ = ]

Result:  3672

Stop.


q(x) = 21 * x + 294 + 3672 / (x - 12)



Example 2:  (2 * x^3 + x - 3) / (x - 3) = (2 * x^3 + 0 * x^2 + x - 3) / (x - 3)


c = 3

a3 = 2

a2 = 0

a1 = 1

a0 = -3


b2 = a3 = 2

3 [ STO ] m

Enter 2


b1:

[ × ] [ RCL ] m [ + ] 0 [ = ]

Result:  6


b0:

[ × ] [ RCL ] m [ + ] 1 [ = ]

Result:  19


br:

[ × ] [ RCL ] m [ + ] 3 [ +/- ]  [ = ]

Result:  54


q(x) = 2 * x^2 + 6 * x + 19 + 54 / (x - 3)


Example 3:  (4 * x^3 + 8 * x^2 - 5 * x + 3) / (x + 2)


c = -2

a3 = 4

a2 = 8

a1 = -5

a0 = 3


b2 = a3 = 4


2 [ +/- ] [ STO ] m 

Enter 4


b2:

[ × ] [ RCL ] m [ + ] 8 [ = ]

Result:  0


b3:

[ × ] [ RCL ] m [ + ] 5 [+/-] [ = ]

Result:  -5


br:

[ × ] [ RCL ] m [ + ] 3 [ = ]

Result:  13


q(x) = 4 * x^2 - 5 + 13 / (x + 2)


I think this is a fundamental algorithm for students and math enthusiasts to learn, and it’s fairly simple to get a hang of it. 


Until next time,


Eddie


Quick update: Starting October 5, 2024, my schedule will allow me to blog once a week. Regular posts will go live every Saturday. Thank you for your support and compliments. I wish you all well.


All original content copyright, © 2011-2024. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.


  

Saturday, September 28, 2024

TI-84 CE and TI-86: Matrix Row Statistics

TI-84 CE and TI-86: Matrix Row Statistics


Introduction


The program MROWST will take a matrix and a desired row and calculate three statistics points:


* Sum of the row

* Mean of the row

* Difference Vector: row – mean for each element


TI-84 CE Program MROWST


Matrices used: [ J ] (entry matrix), [ I ] (difference vector)


Input “MATRIX? “, [ J ]

Input “ROW? “, R

dim([ J ])

Ans(2) → D

0 → S

For(I, 1, D)

S + [ J ](R, I) → S

End

S / D → M

{1, D} → dim([ I ])

For(I, 1, D)

[ J ](R, I) – M → [ I ](1, I)

End

ClrHome

Disp “SUM: “ + toString(S)

Disp “MEAN: “ + toString(M)

Disp “DIFF VECTOR:”

Pause [ I ]


TI-86 Program MROWST


Matrices used: MJ (entry matrix), MD (difference vector), mone (vector of ones)


Input “Matrix? “, MJ

Input “Row? “, R

dim MJ

Ans(2) → D

D → dim mone

Fill(1, mone)

dot(mone, MJ(R)) → S

S / dim mone → M

MJ(R) - (M * mone) → MD

ClLCD

Disp “Sum:”, S

Disp “Mean:”, M

Disp “Diff Vector:”

Pause MD


Example


Matrix:

[ [ -9, -4, -1, -9, 4 ]

[ -9, -7, -4, -4, 9 ]

[ 7, 1, -9, -7, 8 ] ]


Row 1:

Sum: -1

Mean: -0.2

Difference Vector: [ 9.2, -3.8, -0.8, -8.8, 4.2 ]


Row 2:

Sum: -15

Mean: -3

Difference Vector: [ -6, -4, -1, -1, 12 ]


Row 3:

Sum: 0

Mean: 0

Difference Vector: [ 7, 1, -9, -7, 8 ]



Source:

Stuerke, Cecil. “Demonstration of Principal Component Analysis on TI-86” IEEE 2008



Eddie


Quick update: Starting October 5, 2024, my schedule will allow me to blog once a week. Regular posts will go live every Saturday. Thank you for your support and compliments. I wish you all well.



All original content copyright, © 2011-2024. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.

Sunday, September 15, 2024

Numworks: Allowing Repeated Calculations in Python

Numworks: Allowing Repeated Calculations in Python



Introduction


Say we want the user to repeat a calculation or a routine for as long as the user wants. At the end of each calculation, the user is asked if they want another calculation. The user enters one of two possibilities:


1 for an additional calculation

0 for no more calculation


A flag variable is set up with a default value of 1. As long as this value remains at 1, the calculation repeats.


Scrip structure (I named this variable rptflag, but it can be any name):


rptflag=1


while rptflag!=0:

  …

  < insert inputs and show results >

  …

  print(“Again? No = 0, Yes = 1”)

  rptflag=eval(input())


Entering 0 for the Again? Question exits the loop. We need the eval (evaluate) or int (input) because leaving the input command alone defaults the input to a string.


For the sample scripts below, the escape velocity off the surface of planets and other celestial objects are calculated.


Repeated Loop: General


This script does not require any special modules.


Script: rptdemo1 (We can use this on any calculator or platform)


from math import *


# repeat demonstration 

# set up repeat flag

rptflag=1


while rptflag!=0:

  print("ESCAPE VELOCITY")

  m=eval(input("Mass (kg)? "))

  r=eval(input("Radius (m)? "))

  v=sqrt(1.33486e-10*m/r)

  print("Velocity: ",v,"\nm/s")

  print("Again? no=0, 1=yes")

  rptflag=eval(input())




Repeated Loop: Numworks – using the keyboard


Instead of having the user enter 0 or 1, the user presses the keys 0 or 1. To allow the user key presses, use the Ion module. KEY_ZERO is for the 0 key and KEY_ONE is for the 1 key.


To make the screen look presentable, I’m clearing the screen. This is accomplished by the use of the Kandinsky module. The use of the Kandinsky module was suggest to me on Reddit by Feeling_Walrus3033, and I give credit and gratitude for the suggestion.


The line:


fill_rect(0,0,320,240,(255,255,255)) creates a blank white screen.


Clearing the screen this way will call for a way to display text on the screen. Unfortunately the print() command won’t do it. Kandinsky comes to the rescue with the draw_string command. The syntax for the draw_string command is:


draw_string(“text” or variable containing the string, x pixel, y pixel, [text color], [background color])


Colors are optional. The default is black text on white background.


Keep in mind that using this method will require more memory.


Script: rptdemo2 (Specific to Numworks, for other platforms and calculator, check your specific manual)


from math import *

from ion import *

from kandinsky import *

# repeat demonstration 


# set up keys

def key():

  while True:

    if keydown(KEY_ZERO):

      return 0

    if keydown(KEY_ONE):

      return 1


# set up repeat flag

rptflag=1


while rptflag==1:

  print("ESCAPE VELOCITY")

  m=eval(input("Mass (kg)? "))

  r=eval(input("Radius (m)? "))

  v=sqrt(1.33486e-10*m/r)

  

  # build strings

  s1="Velocity: "+str(v)+" m/s"

  s2="Again? no=0, 1=yes"

  fill_rect(0,0,320,240,(255,255,255))

  draw_string(s1,0,0)

  draw_string(s2,0,20)

  rptflag=key()


draw_string("DONE",0,40,(255,0,0))



Sample Data to Try



Mass (kg)

Radius (m)

Escape Velocity (m/s)

Earth

5.972168E24

6378.137E3

11179.88618486758

Jupiter

1.8982E27

71492E3

59533.32250562

Sun (Solar System)

1.9885E30

6.957E8

617688.6988877566


E: [ ×10^x ] button, shown as “e”



Note: I will be in Nashville for the 2024 HP Handheld Conference on September 21-22, 2024. The next scheduled post will be on September 28, 2024.


Take care,


Eddie


All original content copyright, © 2011-2024. Edward Shore. Unauthorized use and/or unauthorized distribution for commercial purposes without express and written permission from the author is strictly prohibited. This blog entry may be distributed for noncommercial purposes, provided that full credit is given to the author.



Casio fx-CG 50: Centroid of a 2D spaces

Casio fx-CG 50: Centroid of a 2D spaces The program CENTROID calculates the center point for an area covered by: y(x) ≥ 0, x ≥ low...