Monday, May 23, 2016

Fluidic computers - Logic gates

In an innocent way, and mainly based on my ignorance, in 2001 I developed an online toy about building tiny computing objects with logic blocks:
Is my OBBLOG

Ignoring the equivalences of the Karnaugh table, OBBLOG contains all the possible logic gates with two inputs and one output.

This is the partial living OBBLOG Truth Table:





For to build a operating toy, I added forks, crossings at different levels and  bit visualizers. (Similar to a light bulb)

However, the toy did not have flip-flops, so you could not make a numbers counter, although small binary calculators 1 to 16 bits.

The toy allows to build little and simple animated toys:


Or more complex constructions:
Binary Tree:



But from the initial basic logic gates, I discovered that it was possible to build a flip-flop:
(And consequently a counter of binary numbers):
 (The obblog allows a closed loop that continues 
to circulate indefinitely if not obstructed)


Thanks to this, the obblog could become able to build calculators calculating in binary system and be able to show results in decimal system. But being only in 2 dimensions can never bequeath to do what you can get to perform with Minecraft. (Koala steamed) (see: official Minecraft logic gates)



(without flip-flops)






I posted all this, because yesterday I found similar artifacts along the history of computing:
The article published in Scientific American the December of 1964:

Fluid logic devices, all based in the Coanda effect: 









And the conference at MIT:  
Referred by:  Fluidic computing at Bowles Fluidics: 
http://strangebits.blogspot.com.es/2007/05/i-had-pleasure-of-participating-in.html

Coding and computation in microfluidics.
http://cba.mit.edu/events/07.05.fluid/

And the conference from Manu Prakash, 
http://cba.mit.edu/events/07.05.fluid/Prakash.pdf

The manu Prakash Thesis: (About "microfluidic bubble logic"), and inside this beautiful Truth table about logic gates and its equivalents in transistors, valves, electrical devices, and fluidics:



Some examples of projected fluidic devices:
(from Prakash thesis)
 Integrated fluidic logic gates with a schematic integrated control circuit 



  
The main patents about fluidics, come from the sixties:
https://www.google.com/patents/US4854176
(from wikipedia)

And schema about Coanda effect from Popular Science (Jun 1967 Pag 118) : 

And the:  Fluidics: Basic components and applications 
By: James W. Joyce  (1977; Unclassified: 1983)





And from the conference:
APPLIED HYDRAULICS AND PNEUMATICS U5MEA23 Prepared by Mr. Jayavelu.S & Mr. Shri Harish Assistant Professor, Mechanical. http://slideplayer.com/slide/5675986/







I would like to see these companions of my program, running.

Anyway, everybody can see them inside the Bowles products:
 

 
 

And inside of the Theranos patented devices: (Lab-on-a-chip)




 //////////////////////////////ADDED 2019/09/30//////////////////////////////////////

An the works of William Phillips (economist)
His contribution to Economics and Mathematics: The Phillips Curve:





William Phillips and his: MONIAC (Monetary Income Analogue Computer) Also known as: Phillips Hydraulic Computer:

William Phillips and his MONIAC

The Moniac machine is a dynamic model of a working economy:



"Phillips ended up at the London School of Economics (LSE) and became very interested in Keynesian theory. It was at this time that he built the Moniac machine. In 1958, Phillips published his seminal work on the relationship between inflation and unemployment. He moved back to Australia  in 1967, before passing away in Auckland in March 1975."

"At LSE [1] Phillips was interested in the circular flow of money model. With his knowledge of hydro-mechanics, Phillips realised that he could build a machine that would take the static circular flow model out of the textbook and into a dynamic 3 dimensional setting, by using water to represent the flow of money. Using a diverse range of materials including bits and pieces from obsolete Lancaster bombers, the first Moniac was created in his landlady’s garage. It was built at a cost of £400 – over $32,000 in today’s money."

"The machine was unveiled in a seminar at LSE in 1949, and Phillips explained how his machine could be used to demonstrate the complex interrelationships between macroeconomic variables such as consumption, taxes, government spending, investment, savings, interest rates and exchange rates. A second machine was built to represent the rest of the world and introduce trade flows into the domestic economy."


Making Money Flow: The MONIAC YouTube: 

reservebankofnz: (Reserve Bank museum in Wellington)

 
From: LSE’s James Meade Archives:


Here is a schematic drawing of MONIAC, courtesy of LSE’s James Meade Archives, with more detail explaining the machinations  (From: http://nautil.us/blog/the-rube-goldberg-machine-that-mastered-keynesian-economics )


A clearer, more modern schematic of the device
Nicholas Barr, in A.W.H. Phillips: Collected Works in Contemporary Perspective by Robert Leeson 


More:
 

By: Andrew Adamatzky

 
 

///////////////////////////////////////////////////////////////////////////////////////////////////
More serious and basic information: Introduction to fluid Mechanics: (Dead Link)

Follow: Reflections about all this at: (Dead Link) https://plus.google.com/communities/102467630739607363236 

[1] LSE: London School of Economics.

Wednesday, May 11, 2016

Dancing numbers: (Math Circus)

Dancing numbers: Numbers Circus: Modulo choreography.
( And:  Circus for to tame numbers, too )

After the post dedicated to dancing sort algorithms,  I think it's time to show a program made and published in 2004, which it could be useful in teaching elementary mathematics.


Is the "Dancing numbers

Originally made for MathCats.com , it never has been published. Finally I posted it on my page so do not be missed for the moment.

The program allows you to manipulate a lot of integers (up to 2000) with some simple rules: decide the number of columns that are to line up neatly from lowest to highest.
(Also possible to arrange smaller amounts of numbers)

The program allows for reflection on the divisibility of numbers and remainders:

It is also advisable to use the mode 9 columns, that shows the rule of divisibility for 9.
(The sum of all members of any number equals the heading number of the column)

And all the rules explained in https://en.wikipedia.org/wiki/Modular_arithmetic
(related to addition, subtraction, multiplication and division (sometimes), and congruence).

Here is a sample of how the program works:




You can use the application here: http://www.nummolt.com/obbl/dancingnumbers/modular_xtd_01.html

I hope its use will be useful to teach elementary mathematics.

Sunday, May 8, 2016

Noting mathematics education in the world, from the statistics page of my Android apps

This is just a small observation, based on my own stats:
As the numbers that I show are not too high, observation may not have enough value.

Typically, the math apps downloads have a proportion of users fairly well distributed among all countries. However, there is always a predominance of the US downloads:

Example graph of a usual app of active users statistics:


(humble numbers related to a calculator)

In my  Google Play page, there is one of the oldest applications that I've done, devoted to linear algebra and the  Gauss-Jordan elimination as a method of solving two equations with two unknowns.

For the application to be a little more attractive, I called it "Adding apples and oranges", referring to an equation are getting really different variables to give a result.


The proportion of current statistics of this application are quite different from other applications. There is a predominance of US downloads:

(humble numbers related to a Apples and oranges app)


While this difference so marked, it makes me think:
It could be that the education authorities of the US had greater knowledge of applied mathematics than education authorities of other countries?

Knowledge of the intellectual basis of the information revolution which we live has influenced the educational guidance of the US?
Or is the result of many parents with deep and old computer knowledge?

What is it that justifies this big difference?

I've searched Common Core related items with the elimination of Gauss-Jordan:
Here are some examples about the related items:

CCSS.MATH.CONTENT.8.EE.C.8 - A, B, C.
CCSS.MATH.CONTENT.HSA.REI.C.6
CCSS.MATH.CONTENT.HSA.REI.D.12


I can not draw a conclusion. Just leave the data in case anyone is able to solve these questions.




Thursday, December 31, 2015

Touch Fraction ℚ (1.4.x)


New version of Android App "Touch Fraction ℚ"  (version 1.4.x and up)
https://play.google.com/store/apps/details?id=nummolt.touch.fraction


Evolution of the app over the years: (1993-2015)
In 1993 I developed the first executable (for Windows 3.1) of Touch Fraction ℚ (Racional.exe):


It was my first attempt of to show an interactive representation of Rational numbers as fibres in (Z * Z {0}) and arrangement in Q.
As the Rational representation in Wikipedia:  Rational Numbers:


In 2013 I made the new version of the app: The translation of the original executable to the Android OS.
The interaction became extended to the fraction:
The pie fraction to navigate across the fractions, and the rational representation to navigate across the equivalent fractions. (and select the range of available denominators)



In 2015 after the development of Touch Integers ℤ (+ - × ÷) (https://play.google.com/store/apps/details?id=com.nummolt.touch.integers)
This time, I was able to afford the next step:
Explain fractions and rational numbers as the prime factorization of its members: numerator and denominator.
This is the new version of Touch Fraction ℚ:




Interact with the fraction, build fractions adding or removing prime factors in the numerator or in the denominator.
Simplify fractions dragging common prime fractions to the "common" zone, and invert fractions with the "^-1" button.  

Touch Fraction ℚ is a complete tool to understand positive fractions, negative fractions, positive and negative numerators, positive and negative denominators, equivalent fractions, and inverted fraction.

Saturday, December 19, 2015

Ancient garden machinery

Some days ago, I stumbled upon this page:


There, there's also a reference to the work of Chandra Mukerji:  
"Territorial ambitions and the gardens of Versailles".
Chandra Mukerji - Cambridge University Press, Sep 25, 1997 - History - 393 pages

There: "Chandra Mukerji highlights the connections between the seemingly disparate activities of engineering and garden design, showing how the gardens at Versailles showcased French skills in using nature and art to design a distinctively French landscape and create a naturalized political territoriality."

More territorial models:
Mississippi River Basin Model:
 

 
 
 
 
From my point of view is a suggestive research field. I created a group google plus to continue the search :

"Ancient garden machinery(broken link, obvously)

If someone wants to help, he will be well received in the group.

Tuesday, November 10, 2015

Touch Integers ℤ (+ - × ÷)

Touch Integers is the evolution of the Touch decimals Place value ±. (in the same blog)
Touch decimals could not easily multiply or divide numbers:


I've started my reflections about this 20 years ago:
Is very easy add and subtract graphically. One can regroup the tokens of each order, regroup, carry or borrow tokens, and you can obtain the result in a simulation of abacus.


But not so easy to practice multiplication or division in this visual and interactive way

I looked the inside of the numbers:

Inside the numbers there are the components of the number: The prime factors.

To multiply two integers you must regroup the components of the two numbers.

To divide a integer, you must separate the components.

The program only works with integers. adds, subtract, multiplies and divides (but only exact division) 

Is my latest Android App: 




At Google Play: 
https://play.google.com/store/apps/details?id=com.nummolt.touch.integers

I hope you will find it useful for teaching.

Some animations:

At left: two abacuses (two numbers stacked). 
At right two circles with the prime factors. (two circles with prime numbers stacked)
At right edge: all the prime numbers available to the app. 

To create a number:  Tap on the cells at left. The app shows the number
To add: Drag the tokens from one abacus to the other.
To subtract: Tap the sign key and drag from one abacus to the other.
To multiply: (the numbers must be previously created with the earlier previous steps)
Drag from one prime circle to the other prime circle.
To Divide a number:
Drag the prime numbers outside the prime circle:
Release prime factors to the other prime circle (integer division and multiplication) 
Release prime factors between the prime circles (integer division)
Release prime factors in the list of the right edge: (integer division and erase the prime factor)
Scroll and pick a prime number from the list of the right edge:

And release it in the free zone, or in a prime circle (multiplication) 

Playing with 12*12:


Creating two prime numbers: 
Multiply them. 
Restoring to the original state.
Throwing the prime numbers to the primes list. 



Picking numbers from the big list of prime numbers:
Playing with 2; 3; 5; 7; 11; 13.
1001; 30 and 30,030


(In the current version the top prime number available is 19,874,419)


Multiplication Table with Prime Numbers made with elements from Touch Integers:
 
Multiplication Table

 



///////////////////////////////////////////////////ACKNOWLEDGEMENTS///////////////////////////////////////////////////////




Jacobo Bulaewsky: (Arcytech.com (broken)) (12/08/1955 - 08/25/2004)

Brian Sutherland: ( http://www.our-montessori.ca ) Montessori methods adapted to computer. 
(Shockwave Player activities: covering addition, subtraction, multiplication and division) 
Long multiplication: https://www.youtube.com/watch?v=qDMXNjtuqqo
Long division: https://www.youtube.com/watch?v=seJC-1BR_gQ 

Agustín Rayo: (Philosopy professor at MIT) 
And his article about the Prime Numbers, at Scientific American (Spanish version - 02/2010)):

"Ladrillos, candados y progresiones.
El fabuooso mundo de los números primos".


Ulrich Kortenkamp: (Professor für Didaktik der Mathematik. Universität Potsdam. 
Author of "Place Value Chart" and "Cinderella") http://kortenkamps.net/index.php/Hauptseite 
Place Value Chart: Web page: Stellenwerttafel: http://kortenkamps.net/index.php/Stellenwerttafel








Wendy Petti (Teacher and author of MathCats): http://www.mathcats.com 
Nearly 20 years of support and patience with me. And specially for the vision about the position of the places in "Touch decimals Place value ±" which allowed continuing the work well.
Our first work as a team: OBBL Architecture blocks: http://www.mathcats.com/explore/obbl/obbl.html
And "Place Value Party Cake":



Jeff LeMieux: (Builder, teacher along 35 years and software developer) 
Scripts Web Page: http://syzygy.virtualave.net/
For his work and the assistance in the development of Touch Decimals: Option without negative numbers.


Joan Jareño (From: CREAMAT team) http://srvcnpbs.xtec.cat/creamat/joomla/ 
And History of numbers: Calculus: http://xtec.cat/~jjareno/calculus/
For their help in the last steps in the development of "Touch Integers".
* * *

Added later:
Playing with the app "Touch Integers ℤ (+ - × ÷)":
Exploring Mersenne primes: 2^p -1 (Not all are primes) 
nummolt.blogspot.com/2016/06/exploring-mersenne-primes-2p-1.html
https://www.youtube.com/watch?v=sOnkpDihIS4



  

Saturday, October 31, 2015

Dancing Sort Algorithms

Post, only to illustrate the most common types of sorting algorithms:
Graphically, Dance, and Code:

(Graphic from http://www.sorting-algorithms.com/ )
(Videos from: https://www.youtube.com/user/AlgoRythmics )
(Pseudocode: http://visualgo.net/ )
(Pseudocode Shell: https://courses.cs.washington.edu/courses/cse326/03wi/lectures/RaoLect14.pdf )
(Main Links (titles): Wikipedia: https://en.wikipedia.org/wiki/Sorting_algorithm

Sorting Algorithms general animated image:
(Algorithms race)



1.-  Insert:

mark first element as sorted
for each unsorted element
  'extract' the element
  for i = lastSortedIndex to 0
    if currentSortedElement > extractedElement
      move sorted element to the right by 1
    else: insert extracted element



2.- Select:

repeat (numOfElements - 1) times
  set the first unsorted element as the minimum
  for each of the unsorted elements
    if element < currentMinimum
      set element as new minimum
  swap minimum with first unsorted position



3.- Bubble:

do
  swapped = false
  for i = 1 to indexOfLastUnsortedElement
    if leftElement > rightElement
      swap(leftElement, rightElement)
      swapped = true
while swapped


4.- Shell:

                                # Start with the largest gap and work down to a gap of 1
                                     foreach (gap in gaps){
                                # Do a gapped insertion sort for this gap size.
                                                     # The first gap elements a[0..gap-1] are already in gapped order
                                                     # keep adding one more element until the entire array is gap sorted  
                                     for (i = gap; i < n; i += 1){
                                            temp = a[i]
                                            for (j = i; j >= gap and a[j - gap] > temp; j -= gap){
                                                  a[j] = a[j - gap]
                                            }
                                            a[j] = temp
                                      }
                                }


5.- Merge:

split each element into partitions of size 1
recursively merge adjancent partitions
  for i = leftPartStartIndex to rightPartLastIndex inclusive
    if leftPartHeadValue <= rightPartHeadValue
      copy leftPartHeadValue
    else: copy rightPartHeadValue
copy elements back to original array


7.- Quick:

for each (unsorted) partition
  set first element as pivot
  storeIndex = pivotIndex + 1
  for i = pivotIndex + 1 to rightmostIndex
    if element[i] < element[pivot]
      swap(i, storeIndex); storeIndex++
  swap(pivot, storeIndex - 1)