C
CoreyWhite
The following experiment is a demonstration of TIME TRAVEL. When
writing this program, and testing it out I found that sometimes the
program would engage itself in time travel but other times it would
not. After careful testing and reprogramming I have optimized the code
so it should work every time, however I recommend that you leave the
room while it is running and think of something else. It takes about 5
minuets to run so it is better if you don't stare at a blank screen.
Here is how the double clock experiment operates:
The program loops like this:
LOOP
wait
a = a + time
wait
b = b + time
GOTO LOOP
c = time
Then it checks to see if the differance between a and b, is correct
compared to c. In normal physics it should be, but if the program time
travels then the output will be different. To show you what I mean
let me give you an example of the program in operation:
wait 10
a = a + time 10
wait 10
b = b + time 20
wait 10
a = a + time 30
wait 10
b = b + time 40
wait 10
a = a + time 50
wait 10
b = b+ time 60
-
Now A = 90 & B = 120
-imediately check time-
C = time 60
Using logic we can deduce that A should be exactly C / 2 smaller than
B, but when you run the program the time differance can vary
considerably in either direction. On top of that, the time it takes to
run the program is not constant either. What conclusions can we draw
from this?
I'll show you some example output and then give you the source:
Time A: 146124514
Time B: 146270790
Time C: 293157
C / 2 = 146578.5
Actual Difference 145276
Time A was 1302.6 ticks into the future, or maybe time b was 1302.6
ticks into the past.
Here is some more real output:
Time A: 144371012
Time B: 144515341
Time C: 289188
C / 2 = 144594
real difference: 144329
time A was 265 ticks into the future, or time b was 265 ticks into the
past.
I wish I had an atomic clock to experiment with, but here is the
source:
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <math.h>
int main()
{
clock_t c0, c1, c2; /* clock_t is defined on <time.h> and
<sys/types.h> as int */
long count;
printf ("using UNIX function clock to measure CPU time ... \n");
for (count = 0; count < 1000; count++){
for(int cnt1 =0; cnt1 < 100000; cnt1++){
c1 = clock();
}
c0 = c0 + clock();
for(int cnt2 =0; cnt2 < 100000; cnt2++){
c1 = clock();
}
c2 = c2 + clock();
}
c1 = clock();
printf ("\tend (CPU); %d\n", (int) c0);
printf ("\tend (CPU2); %d\n", (int) c2);
printf ("\tend (NOW); %d\n", (int) c1);
return 0;
}
writing this program, and testing it out I found that sometimes the
program would engage itself in time travel but other times it would
not. After careful testing and reprogramming I have optimized the code
so it should work every time, however I recommend that you leave the
room while it is running and think of something else. It takes about 5
minuets to run so it is better if you don't stare at a blank screen.
Here is how the double clock experiment operates:
The program loops like this:
LOOP
wait
a = a + time
wait
b = b + time
GOTO LOOP
c = time
Then it checks to see if the differance between a and b, is correct
compared to c. In normal physics it should be, but if the program time
travels then the output will be different. To show you what I mean
let me give you an example of the program in operation:
wait 10
a = a + time 10
wait 10
b = b + time 20
wait 10
a = a + time 30
wait 10
b = b + time 40
wait 10
a = a + time 50
wait 10
b = b+ time 60
-
Now A = 90 & B = 120
-imediately check time-
C = time 60
Using logic we can deduce that A should be exactly C / 2 smaller than
B, but when you run the program the time differance can vary
considerably in either direction. On top of that, the time it takes to
run the program is not constant either. What conclusions can we draw
from this?
I'll show you some example output and then give you the source:
Time A: 146124514
Time B: 146270790
Time C: 293157
C / 2 = 146578.5
Actual Difference 145276
Time A was 1302.6 ticks into the future, or maybe time b was 1302.6
ticks into the past.
Here is some more real output:
Time A: 144371012
Time B: 144515341
Time C: 289188
C / 2 = 144594
real difference: 144329
time A was 265 ticks into the future, or time b was 265 ticks into the
past.
I wish I had an atomic clock to experiment with, but here is the
source:
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <math.h>
int main()
{
clock_t c0, c1, c2; /* clock_t is defined on <time.h> and
<sys/types.h> as int */
long count;
printf ("using UNIX function clock to measure CPU time ... \n");
for (count = 0; count < 1000; count++){
for(int cnt1 =0; cnt1 < 100000; cnt1++){
c1 = clock();
}
c0 = c0 + clock();
for(int cnt2 =0; cnt2 < 100000; cnt2++){
c1 = clock();
}
c2 = c2 + clock();
}
c1 = clock();
printf ("\tend (CPU); %d\n", (int) c0);
printf ("\tend (CPU2); %d\n", (int) c2);
printf ("\tend (NOW); %d\n", (int) c1);
return 0;
}