Visual computation using aliasing and interference


Subject: Visual computation using aliasing and interference
From: ca314159 (ca314159@bestweb.net)
Date: Mon Oct 09 2000 - 12:28:01 MET DST


The similarity of the slide rule to a musical instrument
  is interesting.
  
  If say the C slide is moved to some point along the
  D scale, then the lines on the C scale which line up
  with lines on the D scale are particularly interesting
  from the point of view of having simple precise values
  for the multiplication result. From an analytical point
  of view it would be nice to have a slide rule that
  emphasized these particular alignments.

  A Moire aliasing might emphasize these aligments if the
  slide rule scales were extended and a transparency of
  one scale were overlaid on the other scale. Instead of
  using a transparency moving over a hard copy, the two
  might be hologrammed together so that instead of two
  movable scales, only the projecting beam illuminating
  the hologram would need to move as a parameter, resulting
  in a percieved motion of the two slides, via perspective.

  If the scales were plotted differently, the more continuous
  wave interference might be employed, instead of the more
  particulate pixel aliasing. In this way negative values
  may be used to encode further information (in the same
  sense of superposed colors as opposed to filtered colors).

  Analogously, instead of a bunch of 'digital notes',
  a higher level language or representation, of interfering
  functions, may be employed harmonically (in the same sense
  of dropping D.C. fluctuations below the zero point (volt)
  baseline in order to get an equivalent A.C. represention.);
  This being done using the duality relation between point
  and line[1].

  This would be useful for eliminating 'non-whole' factors
  (based on the scale interval used) so that only the integral
  factors were visible. Graphically representing the
  integers in this manner for the purpose of prime
  factorization would be visually formidable[2], but
  utilizing quantum computers for prime factorization
  essentially performs this same activity while limiting the
  'visual' results to more manageable dimensions when
  its wave-function collapses.

  In this sense, the amusing quantum/relativistic effects
  appear to be more vestigal anomalies of the neglected
  analog method of physical observation rather than
  'magical' physical effects in a digitally oriented world.
  But in a sense one could say alittle magic will always
  be there in that unresolved twilight zone where dualities
  crossover[3] through the looking glass partitioning them.

  Are there any ADSP hybrid processors
  which utilize both highspeed aspects of analog computation
  combined with digital precision to bridge the complexity
  tradeoff ?

[1] Nomography, Douglas P. Adams, 1964
[2] Boris Stechkin, Yuri Matiyasevich, visual sieve:
http://www.informatik.uni-stuttgart.de/ifi/ti/personen/Matiyasevich/Journal/Sieve/Sieve.html

LINKS
   
SIRDS/SIRTS:
These are horizontally 'polarized' and require the observer to
be a part of the 'experiment'. It might be interesting to make
these so that they can be rotated. They use the observer
to complete their implied 'calculation'/correlation via
visual aliasing/projection and perspetive:
 http://google.yahoo.com/bin/query?p=%2bSIRDS+%2bSIRTS&hc=0&hs=0

Quantum Computer Simulators with source code:
 http://www.dcs.ex.ac.uk/~jwallace/simtable.htm

Analog Quantum Computers:
 http://www.theory.caltech.edu/~quic/analog.html

These example the way intersections represent 'paradoxes'
that are 'resolvable' in higher dimensions.

2-d immersed 3-d Moebius surface:
 http://www.cut-the-knot.com/do_you_know/moebius.html

3-d imersed Klein Bottles:
 http://www.kleinbottle.com/

Other links:

Grain Aliasing:
 http://www.photoscientia.co.uk/Grain.htm

Dynamic vs. Static Aliasing:
 http://cvs.anu.edu.au/johannes/psyc16/lecture3_10.html

Crossover and other Distortions:
 http://www.2xtreme.net/regina-r/tmov/distorted.htm

---------------------------------------------------------------------
% A printable slide rule
% From postscript written by Andy Kinsman <kinsman@ssd.kodak.com>
% edited to extend the C/D ticks. Print two copies, one on
% paper and one on transparency. Observe the aliasing
% between the scales.

% for on glass debugging clear screen uncomment next line
%clippath 1 setgray fill 0 setgray

/Helvetica findfont 10 scalefont setfont
0 setlinewidth
/inch {72 mul} def
/scale-len 10 def % length of scales in inches
/hash-height 0 def
/hash-incr 0 def
/tag-it 0 def
/raise-5 0 def
/str 20 string def
/tags ( 123456789) def % zeros turn into blanks

% flip axis used for B&D scales
/flip-axis {
1 -1 scale
} def

% flip font used for B&D scales
/flip-font {
currentfont [ 1 0 0 -1 0 0 ] makefont setfont
} def

% flip both used for B&D scales
/flip-it {
flip-axis
flip-font
} def

% for log scales
% ( start increment end hash-height hash-incr tag-it raise-5 -- )
/hash-it
{
         /raise-5 exch def
         /tag-it exch def
         /hash-incr exch def
         /hash-height exch def
         {
                                 % draw vertical hash
         dup log scale-len mul inch 0 moveto 0 hash-height inch rlineto
                                % extend 5 lines up a bit
             raise-5 1 eq
                {
                         dup 1000 mul cvi 1 add % round up a bit
                             str cvs
                             hash-incr log cvi 1 getinterval % (
asc-digit -- )
                             (5) eq { 0 hash-height .3 mul inch rlineto
                               }
                               if
                }
                if
                                % add number string
                                                        % ( num --
)
             tag-it 1 eq % ( num
bool -- )
                {
                  1000 mul cvi 1 add % ( inum
-- )
                  str cvs % ( string
-- )
                  hash-incr log cvi 1 getinterval % (
asc-digit -- )
                  cvi % ( int --
)
                  tags exch 1 getinterval
                  show % ( -- )
                }
                { pop }
                ifelse
         } for
stroke
} def

% for linear scales
% ( start increment end hash-height hash-incr tag-it raise-5 -- )
/hash-it2
{
         /raise-5 exch def
         /tag-it exch def
         /hash-incr exch def
         /hash-height exch def
         {
                                 % draw vertical hash
         dup scale-len mul inch 0 moveto 0 hash-height inch rlineto
                                % extend 5 lines up a bit
             raise-5 1 eq
                {
                         dup 1000 mul cvi 1 add % round up a bit
                             str cvs
                             hash-incr log cvi 1 getinterval % (
asc-digit -- )
                             (5) eq { 0 hash-height .3 mul inch rlineto
                               }
                               if
                }
                if
                                % add number string
                                                        % ( num --
)
             tag-it 1 eq % ( num
bool -- )
                {
                  1000 mul cvi 1 add % ( inum
-- )
                  str cvs % ( string
-- )
                  hash-incr log cvi 1 getinterval % (
asc-digit -- )
                  cvi % ( int --
)
                  tags exch 1 getinterval
                  (.) show
                  show % ( -- )
                }
                { pop }
                ifelse
         } for
stroke
} def

% for linear scales with no labels
% ( start increment end hash-height hash-incr tag-it raise-5 -- )
/hash-it3
{
         /raise-5 exch def
         /tag-it exch def
         /hash-incr exch def
         /hash-height exch def
         {
                                 % draw vertical hash
         dup scale-len mul inch 0 moveto 0 hash-height inch rlineto
         } for
stroke
} def

/rule-c {
% start increment end hash-height hash-incr tag-it raise-5
1.0 1.0 10.0 6.20 1 1 0 hash-it % units
/Helvetica findfont 7 scalefont setfont
1.0 0.1 2.0 6.13 10 1 0 hash-it % 1/10ths
/Helvetica findfont 10 scalefont setfont
2.0 0.1 10.0 6.10 10 0 1 hash-it % 1/10ths
1.0 .01 2.0 6.07 100 0 1 hash-it % 1/100ths
2.0 .02 4.0 6.07 0 0 0 hash-it % 1/50ths
4.0 .05 10.0 6.07 0 0 0 hash-it % 1/20ths
} def

/rule-d {
% start increment end hash-height hash-incr tag-it raise-5
1.0 1.0 10.0 4.20 1 1 0 hash-it % units
/Helvetica findfont 7 scalefont setfont
flip-font
1.0 0.1 2.0 4.16 10 1 0 hash-it % 1/10ths
/Helvetica findfont 10 scalefont setfont
2.0 0.1 10.0 4.10 10 0 1 hash-it % 1/10ths
1.0 .01 2.0 4.07 100 0 1 hash-it % 1/100ths
2.0 .02 4.0 4.07 0 0 0 hash-it % 1/50ths
4.0 .05 10.0 4.07 0 0 0 hash-it % 1/20ths
} def

/rule-l {
% start increment end hash-height hash-incr tag-it raise-5
0.0 0.1 1.0 0.20 1 1 0 hash-it2 % units
0.0 0.05 1.0 0.15 1 0 0 hash-it3 % 1/2s
0.0 0.01 1.0 0.10 1 0 0 hash-it3 % 1/10ths
0.0 0.005 1.0 0.07 1 0 0 hash-it3 % 1/20ths
} def

/rule-ab {
% start increment end hash-height hash-incr tag-it raise-5
1.0 1.0 10.0 0.20 1 1 0 hash-it % units
1.0 0.1 10.0 0.10 10 0 1 hash-it % 1/10ths
1.0 .02 2.0 0.07 0 0 0 hash-it % 1/50ths
2.0 .05 5.0 0.07 0 0 0 hash-it % 1/20ths
} def

/rule-k {
% start increment end hash-height hash-incr tag-it raise-5
1.0 1.0 10.0 0.20 1 1 0 hash-it % units
1.0 0.1 6.0 0.10 10 0 1 hash-it % 1/10ths
1.0 .05 6.0 0.07 0 0 0 hash-it % 1/20ths
6.0 0.2 10.0 0.10 0 0 0 hash-it % 1/5ths
} def

% outlines of the device and some literals
/overlap .25 inch def % glue flap
/half-height 2.25 inch def % height of face
/draw-outline{
   % boxes, and glue text etc.
    0.0 inch 8.0 inch overlap add moveto
   11.0 inch 8.0 inch overlap add lineto
   11.0 inch 8.0 inch half-height 2 mul sub lineto
    0.0 inch 8.0 inch half-height 2 mul sub lineto
   closepath
   stroke
   % cutout area
    0.5 inch 7.25 inch moveto
   10.5 inch 7.25 inch lineto
   10.5 inch 6.25 inch lineto
    0.5 inch 6.25 inch lineto
   closepath
   stroke
   % dotted line under glue
   [5] 0 setdash
    0.0 inch 8.0 inch moveto
   11.0 inch 8.0 inch lineto
   % dotted line between halves
    0.0 inch 8.0 inch half-height sub moveto
   11.0 inch 8.0 inch half-height sub lineto
   stroke
   [] 0 setdash
   % draw slide
    0.0 inch 3.0 inch moveto
   11.0 inch 3.0 inch lineto
   11.0 inch 3.0 inch half-height sub overlap add lineto
   0.0 inch 3.0 inch half-height sub overlap add lineto
   closepath
   stroke
} def

% Comment out next two lines for viewing on glass
9.0 inch 0.1 inch translate
90 rotate

% uncomment out one of the following for the model size you wish
%1.4 1.4 scale % debug size model
0.95 0.95 scale % 10 inch model (just wouldn't fit on 11 inch page as
designed)
%.8 .8 scale % 8 inch model
%.5 .5 scale % 5 inch model
0.1 inch 0.5 inch translate

% C&D scales
%save
%0.5 inch 3.50 inch translate
%23 rotate
%flip-it rule-d flip-it
%grestore

gsave
0.5 inch 0.50 inch translate
rule-c
grestore

showpage

############################################################################
This message was posted through the fuzzy mailing list.
(1) To subscribe to this mailing list, send a message body of
"SUB FUZZY-MAIL myFirstName mySurname" to listproc@dbai.tuwien.ac.at
(2) To unsubscribe from this mailing list, send a message body of
"UNSUB FUZZY-MAIL" or "UNSUB FUZZY-MAIL yoursubscription@email.address.com"
to listproc@dbai.tuwien.ac.at
(3) To reach the human who maintains the list, send mail to
fuzzy-owner@dbai.tuwien.ac.at
(4) WWW access and other information on Fuzzy Sets and Logic see
http://www.dbai.tuwien.ac.at/ftp/mlowner/fuzzy-mail.info
(5) WWW archive: http://www.dbai.tuwien.ac.at/marchives/fuzzy-mail/index.html



This archive was generated by hypermail 2b25 : Mon Oct 09 2000 - 12:29:49 MET DST