Page 3 of 6 FirstFirst 12345 ... LastLast
Results 61 to 90 of 170

Thread: A theory of eveything in 5 pages of program code!

  1. #61
    Quote Originally Posted by Marty Wollner View Post
    So, CJ, if your just gonna sit there and blast me with analytics of observations (which is all YOU have), I have no choice but to repeat; “its all about causality and emergence” and “look at the program code, none of the observed laws are programmed in…” and repeat this conversation, now for the 4th time.
    But you're explicitly programming things like fusion in, rather than letting them emerge.


    Quote Originally Posted by Marty Wollner View Post
    I will prove to you, right here on this forum, that my simple little program implements “Digital Relativity” without bending time and gravity. It’s so easy, a caveman could do it, it’s just a very SIMPLE loop that moves matter and radiation around using a set of loop counters. Its all integer arithmetic… in fact, it removes the need for any event timers in the system; it runs as a simple and pure finite series equation.
    You need to prove to me that your simple little program has something to do with reality. If you prove that your program predicts a global, absolute time, you have proven that your model does not match reality.


    Quote Originally Posted by Marty Wollner View Post
    Did you see the program code (above)?
    I saw some messy, poorly formatted VB-esque pseudocode and made some attempt to decipher it, but saw no reason for it to give any useful results.


    Quote Originally Posted by Marty Wollner View Post
    OK, CJ, actually I’m already in the process of doing this write-up in another brand new paper I should have out by next week named “Flat-Out Disproving Relativity in 120 Minutes”.

    YOU DON’T NEED TO WAIT, I will show you EVERYTHING right here, and RIGHT NOW. OK?
    To clarify, the following is meant as a disproof of relativity?


    Quote Originally Posted by Marty Wollner View Post
    Einstein’s Train Paradox:
    RiderDude is standing on a train traveling at the blazingly fast speed of 3 miles per second (this must be in Japan somewhere, I cant explain why its not metric, though).

    RoadsideDude is standing on the side of the road at the same instant the train happens by and also happens to turn its headlamp on (of course… this guy is still homeless from that big sea wave).

    The heart of the paradox is the question of the speed of the train being added onto the speed of light. Does this occur or not? YES OR NO?
    Quite conclusively no. This was a question early on, with the idea of the emitter's velocity being added in being called the ballistic theory of light or emitter theory. It was raised as an explanation for the null result from the Michelson-Morley experiment. However, it does not fit reality. Light from binary stars would be coming toward us faster on one half of the orbit than on the other half, overtaking light emitted at other parts of the orbit and smearing the image of the stars out across their orbits. We don't see this, we see clearly separated stars.


    Quote Originally Posted by Marty Wollner View Post
    To answer this question, we need to observe how far the light goes from both of the Dude’s points of view. We do so by asking this question:

    When the light hits the mountain up ahead, will RiderDude see it before RoadsideDude?

    If the answer were yes, then that would explain it; the velocity of the train was added onto the velocity of light, so RiderDude watches the light hit the mountain before RoadsideDude.

    If the answer is no, then how can this happen??? ???
    The light was emitted as the train passed the roadside observer while approaching the mountain? Well, the rider will clearly see the reflected light first, as he will be between the mountain and the stationary observer. The stationary observer might even see the rider's silhouette against the mount.


    Quote Originally Posted by Marty Wollner View Post
    Well, we all know the answer is no. So how in the heck can this happen?
    We do? How can what happen?


    Quote Originally Posted by Marty Wollner View Post
    Still with me?

    108 minutes to go.
    Better get started on that disproof then.


    Quote Originally Posted by Marty Wollner View Post
    The Train Flash Incident Specifics:

    Let’s repeat the scenario again with a more analytical approach.


    Both RiderDude and RoadsideDude were standing at mile marker 0 when this whole, stinking thing all went down, EXACTLY at time 12:00:00. The mountain is dead ahead at mile marker 40,003 miles.

    Lets call the speed of light “C” and assume it’s a fixed, pre-determined number, and in this example universe we’re operating in, let’s make it 20,000 miles per second.


    · Speed of light: 20,000 miles per second
    · Speed of the train: 3 miles per second
    · Location of Flash: Mile marker 0
    · The Mountain’s location: 40,003 miles dead ahead
    · One RiderDude is on-board the moving train
    · One RoadsideDude is standing still on the side of the tracks
    · Both Dudes are at mile marker 0 the instant of the flash

    OK?


    12:00:00… At the moment of flashing the lamp:
    · RiderDude: The light is right there in front of him.

    · RoadsideDude: The light is also right there in front of him.
    12:00:01… One second after flashing the lamp:
    And here is the paradox; should we add the speed of the train onto the speed of light flowing away from the train’s (and RiderDude’s) point of perception?
    No.


    Quote Originally Posted by Marty Wollner View Post
    If yes, then:
    ...snip

    I can’t describe the problem any clearer than this. If you still don’t understand after re-reading, try another sport.
    You left a few things out. Like all the calculations that didn't make the above incorrect assumption. The speed of light is constant as measured by all observers.


    Quote Originally Posted by Marty Wollner View Post
    ALL righty, now my program
    ...weren't you just going to disprove relativity?


    Quote Originally Posted by Marty Wollner View Post
    implements the speed of light in the=is SPECIAL WAY that I keep going on and on about, and you keep reminding me about ho its not telling you anything.

    Try to pay attention for a few pages, OK?

    Heck, the explanation is 10 times longer than the code itself.

    I’m implementing everything in terms of GC / tick. There are not fixed speeds, everything is done in relation only to one thing, and that is the maximum resolution of the system: WordSize (the max. numerical limitation is 2**WordSize)
    This doesn't appear to answer anything.

  2. #62
    Quote Originally Posted by Marty Wollner View Post
    Implications

    What is apparent here is that descriptions are different for slow stuff vs. fast. The cutoff apparently occurs at the ½ mark?

    1.3.1 Does this mean that stuff closer to the fastest needs to be processed differently than the slow stuff?

    1.3.2 YES IT DOES !!!!

    1.3.3 The slow stuff needs to be processed by waiting a number of ticks, then moving the object 1 grid location. That’s really straightforward.

    1.3.4 The fast stuff needs to be processed by waiting a numbers of ticks then moving the object that many grid locations. That is NOT straightforward.
    Indeed. It's the sort of thing that should emerge naturally, given your other claims. Might this mean something?


    Quote Originally Posted by Marty Wollner View Post
    Perhaps you need to stare at it for a while, but I’m thinking, NOTHING TRAVELS at speeds between ½ C and C!!! THIS IS CRUCIAL! Please see the Appendix: “Are you stupid, Marty #1”?

    When something passes the ½ way point, there is no going back: the next available speed is C, and now it’s all radiation (and electro-static flow) ONLY!!!
    Which is completely at odds with actual observations...


    Quote Originally Posted by Marty Wollner View Post
    THEY STILL can’t get it to work with a mountain of infinity based formulas, yet I got it to work with two lines of code, and this scaling can be applied to any size U. and still work perfectly…. Automatically drawing the scale in according to the resolution.
    What have you gotten to work? What have you actually accomplished?


    Quote Originally Posted by Marty Wollner View Post
    Now, I want you to refute anything I have said here without saying something about what you think you know about what you think somebody has observed, go right ahead, I wont reply to it any more.
    There is little to refute. Your simulation does this and that, and has no apparent relation to reality.


    Quote Originally Posted by Marty Wollner View Post
    And everything would work just fine.

    Until you try using speeds faster than ½ C.

    At THAT point, scaling IS required in the code.
    Again, this seems like the sort of thing that's supposed to emerge, that you have to do something special to handle a circumstance that causes no unusual effects in the real world is not promising...


    Quote Originally Posted by Marty Wollner View Post
    I’m proposing that as matter gets hot enough (I’m guessing the same ½ way unit number on the heat scale), it begins shedding off radiation all at C.
    This seems like something we should see in our various particle and plasma experiments.


    Quote Originally Posted by Marty Wollner View Post
    The specific mechanism can be either velocity or heat. I don’t think it’s the mean-free velocity of the component, I think its heat. Why do I say this? Because otherwise, how can stuff heat up sitting in a vacuum? In a vacuum, there are “no” collisions with the matter. The matter itself might be vibrating really fast, but that won’t make much of a mean free distance. So I think the mechanism is heat.
    You haven't actually described a mechanism, or even clearly stated what you're looking for a mechanism for...


    Quote Originally Posted by Marty Wollner View Post
    Note that the act of creating radiation is an EXOTHERIC one, relieving the component of energy and thus reducing it’s heat content.
    That would be endothermic, so far as the term applies.


    Quote Originally Posted by Marty Wollner View Post
    Now I have yet to discuss the actual mechanism behind electricity, but if there is one extra particle in all of our even number heat flux exchanges that might be it. That’s just a wild guess.
    The actual mechanism behind electricity?


    Quote Originally Posted by Marty Wollner View Post
    I’m not certain of the mechanism behind our observation of any of this occurrences… its just some root causality going on, but I certainly hope everyone can see how these mechanisms might produce what we view to be “reality”.
    Going to disappoint you, then.

  3. #63
    Quote Originally Posted by Marty Wollner View Post
    I know a lot about simulations. ...snip...
    And you code in VB (tried to code a kind of voxel simulation in VB, at that), don't know to indent or otherwise format your code, and think double buffering's a sufficiently advanced technique that knowledge of supports your claims of skill and knowlede. I'm sorry, but double buffering is trivial. You need the previous state intact to determine the next state, so you put the next state together in another area of memory. It's an utterly basic approach that hardly qualifies as a technique, often being the simplest way to solve a problem. Smarter cellular automaton algorithms involve things like tracking active cells and tricks with pattern matching and reuse of computations...Hashlife, for example.

    You should be talking algorithms and data structures, not bragging about independently developing double buffering. I'll repeat what others have said and advise you to take some classes...you have no idea what you're missing or how much help it can be. This isn't an insult, you really have a huge amount to gain by learning some of what's already out there...read up on that Hashlife algorithm for an example of the return on investment you can get from more complex algorithms. And study up on relativity...it's not something you can decide not to believe in. The fundamentals are quite clearly true...the time dilation effects are easily measured directly with modern instruments. Education's not going to pack you into an inescapable box, in fact it'll do the opposite, showing you the sort of alternative approaches that might be workable. In particular, some of the techniques used in making CFD simulations manageable might have application.

    Anyway, as I said, you need to explain here. I'm not reading your links or watching videos or anything. And focus...you're frantically jumping around and constantly straying to irrelevancies, repeating the same grandiose claims, fragmented/incomplete explanations, and page after page of text without getting anywhere.

    You talk about emergent behavior arising out of your simulation, but you make several references to specifically handling "fusion" of "plasma", "radiation", etc. How do you expect things like nuclear physics to emerge naturally from the simulation when you're hard coding things at such a vastly higher level? You claim (I think, you're not exactly clear) to have simulated a supernova...how? What precisely have you simulated?

    You repeatedly make claims about the simplicity of your simulation and how mainstream theories are overly complicated, what precisely do you mean? How much processing power and storage space do you expect it to take to simulate, say, one hydrogen atom, and how fast do you expect that simulation to run?

  4. #64
    Join Date
    Mar 2004
    Posts
    17,148
    Quote Originally Posted by Marty Wollner View Post
    As far as everyone here insisting that I take some classses and study other peoples work before I proceed, I TOTALLY disagree. Am I'm NOT stupid; I said I have a solid reason for it and I am even more certain that this is the only approach that will be sucessfull. I truely belive this is a unique situation and that it requires thinking outside of the box.
    I don't see any reason why learning the relevant subjects would stop you from thinking outside the box. If you're going to try to show you have something new and useful, you are going to need to know the existing science, and show that you have thought through possible criticisms and have answers for them.

    Here's an article on this issue (I'd strongly suggest reading the full article because it has excellent points for anyone in your situation):

    http://blogs.discovermagazine.com/co...ity-checklist/

    Quote Originally Posted by article
    (1) Acquire basic competency in whatever field of science your discovery belongs to.

    In other words, “get to know what is already known.”
    [...]
    Now, you may object that steering clear of such pre-existing knowledge has played a crucial role in your unique brand of breakthrough research, and you would never have been able to make those dazzling conceptual leaps had you been weighed down by all of that established art. Let me break it down for you: no. There may have been a time, in the halcyon days of Archimedes or maybe even Galileo and Newton, when anyone with a can-do attitude and a passing interest in the fundamental mysteries could make an important contribution to our understanding of nature. Those days are long past. (And Galileo and Newton, let us note, understood the science of their time better than anybody.) We’ve learned a tremendous amount about how the universe works, most of which is “right” at least in some well-defined regime of applicability. If you haven’t mastered what we’ve already learned, you’re not going to be able to see beyond it.
    If you are going to argue against relativity theory, for example, you aren't going to be taken seriously unless you can show you have a very good understanding of the subject.

    Whenever I do ready anyone's work on anything, it makes me more and more exicted becauase I have the entire thing visualized out, and when I find commonlity, for example my approach to perfect reproduceablity, I KNOW I'm onto something.
    No, you THINK you're onto something, but you have admitted yourself you don't know the subjects. If you don't have a very good understanding of the relevant science, you will make fundamental mistakes. It won't matter how long or how hard you work on it, it will just be wrong.
    Last edited by Van Rijn; 2011-Dec-14 at 12:16 AM.

    "The problem with quotes on the Internet is that it is hard to verify their authenticity." — Abraham Lincoln

    I say there is an invisible elf in my backyard. How do you prove that I am wrong?

    The Leif Ericson Cruiser

  5. #65
    Hey everyone.

    I will addess y'all individually in a while.

    While you were answering me, i finished and published my new book and now have 1/2 he C version done. I take it as personal insult to hear anyone say that my code is poorly formatted, give me two days thats all. I will show you. OK?

    I already designed the massive integer data type a few hours ago, and TRUST ME, all of this is comming directly from my visualizations of this I have had for years. I have NOT coded in C in about 3 years, but, now, watch the master at work.

    later!

    check out "Flat out disproving relativity in 120 minutes" right now.

    http://spikersystems.com/FlashNet_Po...120Minutes.htm


    If you look thorough the table of contents, you will find many of your answers, escpecially the "disclaimer" section...
    http://spikersystems.com/FlashNet_Po...#_Toc311503675


    I can answer all of your questions as well, and,
    and while we're at it, check out how my 5 pages of code answers all of THESE questions as well:

    http://spikersystems.com/FlashNet_Po...#_Toc305761053

    gotta scoot, i need to find a c compiler, all i got is this stupid pidgeon...

  6. #66
    Join Date
    Oct 2009
    Location
    a long way away
    Posts
    8,534
    Quote Originally Posted by Marty Wollner View Post
    I already designed the massive integer data type a few hours ago
    You know you can get a standard library to do that for you?
    http://en.wikipedia.org/wiki/Arbitra...etic#Libraries

    Or, even better, use a language that supports it directly.

    watch the master at work.
    Such modesty.

    check out "Flat out disproving relativity in 120 minutes" right now.
    Utterly unreadable. Why would anyone struggle to make any sense of that chaos when we already know it is wrong?

  7. #67
    Join Date
    Oct 2009
    Posts
    1,410
    Quote Originally Posted by Marty Wollner View Post
    check out "Flat out disproving relativity in 120 minutes" right now.
    Tragic. It does no such thing. Why do you think it does?

    I can answer all of your questions as well, and,
    and while we're at it, check out how my 5 pages of code answers all of THESE questions as well
    Part of the problem -- and it's a deep one -- is that you seem not to understand what science is and what it does. So far you have 5 pages of code, but not a single quantitative result to show that your code correctly describes how the universe works (as evidenced by the vast body of experimental results accumulated over the centuries).

    My single page of code has produced precisely the same volume of relevant output as your 5, and I have yet to write my single page of code.

    So until you've done the actual work of reconciling experiment with the predictions of your simulation, it's rather premature to crow (in caps and boldface, no less) that you have achieved anything, let alone some deep insight into the workings of the universe. At this point, your code and mine are functionally equivalent. The hard work is yet to come for you. The "brain burp" part is easy, and that's all you seem to have so far. Until you've done that hard work, I'm sticking with nanognomes. Maybe they're on a grid, but it's nanognomes all the way down.

  8. #68

    Harsh comments unfounded, CJ!

    CJ.. I haven't had time to fully reply to your reply, but I dont like people trashing my code, thats for sure!!
    I'm getting by on about 30 minutes of sleep a day for the past month or so.. I am in full hypo-mania and its times like these when I CAN crank out masterpieces!!

    I'm trying to get this program done now but YOUR distracting me with your unfounded claims of the neatness of my code.

    So, JUST TO SHUT YOU UP ABOUT THIS one blatant and un-founded accusation,

    I went ahead and copied out to the web my SRV_LIB, upon which the entire backbone of FORD STILL rests as we speak, and i havent even been there in 10 years...

    Here are 159 of the cleanest modules you will ever see ever. I challenge you to show me one un-nested statement in all of these modules.
    This code was developed entirely on my own by myself. I have my own terminology for queueing theory that I developed myself.. I dremt it up on my own just like the theory of everything, but that's taken me a bit longer to visualize. This code is portable, it runs on VMS, UNIX and WindowsNT families. It also supports multiple communications protocols concrueently, now in my gaming extentions to this stuff.

    YOU ARE LOOKING AT TOTALLY BULLET-PROOOF CODE. THIS CODE HAS EXECUTED TRILLIONS OF transactions over the years. WITH ZERO ERRORS, swear to God.

    The VB code looked like crap because it isn't meant to be examined except from VB itself, when you "cut and haste" thats' what happenes.

    The only thing more beautiful than this code is the API guide for it, if you want, I'll get it for you along with the list of the 14 plants that ran FCIS and the 130 plants running ANS.

    http://spikersystems.com/FlashNet_Po.../Code/srv_lib/

    dang, CUT ME SOME SLACK, boys!

    In case you dont look at the link here's a few of em...

    Code:
    
    /*
    ** File name:		SRV_AST.C
    ** 
    ** Brief description:	Server shell AST read completion routine
    **
    ** Target system:	Ford Motor Co. POWERTRAIN APPLICATIONS
    **
    ** File type:		C subroutine
    **
    ** Update history:
    ** Date		By		Description
    ** ----		--		-----------
    ** 10-Jul-1996	Marty Wollner	Re-done for PLT and UTM
    ** 11-Oct-1996	Marty Wollner	Perform data marshaling on the srv_queue_head
    **				portion of the messages read
    ** 25-May-1997	Marty Wollner	Under NT, don't check completion status - it
    **				was already checked in the read thread. Also,
    **				don't call srv_read_mbx_ast - this will occur
    **				in the read MBX thread by itself.
    ** 13-Oct-1997	Marty Wollner	Under NT, instead of checking completion status,
    **				perform data marshalling.
    **- 
    ** Full description:
    **
    ** This is the server shell ast completion routine. This routine is kicked off
    ** whenever a read completes for the server's incomming request MBX. The
    ** srv_read_buf buffer will contain the request message, and the read
    ** completion status is located in srv_iostatus. Both are declared external.
    **
    ** The request is either handled as a control message, as an initial request,
    ** or as an unsolicited message. If a request, then we check if the request
    ** should be queued by calling the routine pointed to by srv_enqueue_routine,
    ** if the pointer is not null. If this routine returns success, then the
    ** request it is queued, and the server shell process is waken up to handle it.
    **
    */
    
    #include "srv_include.h"
    #include "srv_xnc_include.h"
    #include "srv_control_include.h"
    
    void	srv_ast (void *ast_param)
    
    {
    
    /*
    ** Local declarations
    */
    #define	MODULE_NAME	"SRV_AST"
    
        struct	SRV_MAX_REC_STRUC	send_buf;	/* Return buffer */
        struct	SRV_MAX_REC_STRUC	*read_buf;	/* Structure pointer */
    
        long	cont_code;				/* Control code */
    
        BOOLEAN	new_msg;				/* New message flag */
        BOOLEAN	check_flag;				/* Check message flag */
        BOOLEAN	queue_flag;				/* Queue request flag */
    
    /*
    ** Begin code here.
    **
    ** Check the completion status of the read, and perform data marshaling.
    */
    
    #ifndef	SRV_PLT_NT
    
        if (! srv_chk_ast_completion (ast_param,
    				  TRUE))
        {							/* If bad, the user has
    **							   already been
    **							   informed */
    	exit (SRV_BAD_EXIT_STATUS);			/* Terminate */
        }
    
    #else
    
    /*
    ** Under NT, call the routine to determine if the endian of the sending
    ** platform does not match the endian of the current platform, and adjust the
    ** srv_queue_head header of the message sitting in srv_read_buf if needed
    */
        srv_qhead_marshal (PSYM_LITTLE_ENDIAN,		/* Current box*/
    		       srv_dmq_pams_show_buffer.endian,	/* Source */
    		       srv_read_buf);			/* Buffer */
    
    
    #endif
    
    /*
    ** Start a loop to dequeue all messages from the MBX, including the first one
    ** which kicked this routine off
    */
        read_buf = (struct SRV_MAX_REC_STRUC *) srv_read_buf; /* Set up pointer */
        while (TRUE)
        {							/* Repeat forever */
    
    /*
    ** If the read came from the XNC server, then set the srv_xnc_activity_flag
    */
    	if (strncmp (read_buf->qhead_str.mbx,
    		     SRV_XNC_IN_MBX,
    		     SRV_MBX_NAME_SIZE) == 0)
    	{
    	    srv_xnc_activity_flag = TRUE;
    	}
    
    /*
    ** The read will have completed using srv_read_buf as the target. Save the
    ** control code of the new request.
    */
    	cont_code = read_buf->qhead_str.cont_code;	/* Save code */
    
    /*
    ** Process the request message by eliminating control messages, unsolicited
    ** inputs, requests in terminate mode, queue full situations, and SRV_IR_IQ
    ** or SRV_IR_QC requests messages received for which an error occurred in the
    ** SRV_RR_RQ response.
    **
    ** Set up the check_flag and queue_flag to control code execution. The variable
    ** check_flag indicates that checking of the message should continue. The
    ** variable queue_flag indicates that the request should be queued.
    */
    	check_flag = TRUE;				/* Start by checking */
    	queue_flag = TRUE;				/* Assume req. queue */
    
    /*
    ** If server control message, handle it, and discontinue checking
    */
    	if ((cont_code >= SRV_CC_MIN) &&
    	    (cont_code <= SRV_CC_MAX))
    	{						/* If control message */
    	    srv_control ();				/* Handle cont. req. */
    	    check_flag = FALSE;				/* Stop message check */
    	    queue_flag = FALSE;				/* Don't queue req. */
    	}						/* End if control msg */
    
    /*
    ** Check for unsolicited input by making sure that the control code is not out
    ** of the range for requests (it was already checked for being a control message
    ** above)
    */
    	if ((check_flag) &&
    	    ((cont_code < SRV_IR_MIN) ||
    	     (cont_code > SRV_IR_MAX)))
    	{						/* If unsolicited inp */
    	    srv_unsol_inp (&read_buf->qhead_str,
    			   srv_in_node,
    			   srv_in_mbx,
    			   srv_proc_name);		/* Call routine to
    **							   handle unexpected
    **							   message */
    	    check_flag = FALSE;				/* Stop message check */
    	    queue_flag = FALSE;				/* Don't queue req. */
    	} 						/* End if unsol. inp. */
    
    /*
    ** We have an initial request message.
    **
    ** If in terminate mode, return error code SRV_EC_TO (orderly shutdown in
    ** progress) if the user is expecting any kind of response, and inform the
    ** system in any case.
    */
    	if ((check_flag) && (srv_terminate))
    	{						/* If in terminate */
    	    if (((cont_code & SRV_IR_IQB) != 0) ||
    		((cont_code & SRV_IR_ICB) != 0) ||
    		((cont_code & SRV_IR_ODB) != 0))
    	    {						 /* If cont. dialog */
    		send_buf.qhead_str.cont_code = SRV_EC_TO; /* Term in progress */
    		send_buf.qhead_str.data_len = 0;	 /* No data */
    
    		if (! srv_write_mbx (&read_buf->qhead_str,
    				     &send_buf,
    				     srv_in_node,
    				     srv_in_mbx,
    				     FALSE,
    				     TRUE,
    				     TRUE))
    		{					/* If send error */
    		    srv_log_shell_msg (MODULE_NAME,
    				       SRV_MSG_SEVERITY_E,
    			    "Error returning EC_TO during orderly shutdown to ",
    				      (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    		}					/* End if send error */
    	    }						/* End if cont dialog */
    
    	    srv_ec_to_cnt++;				/* Count of requests not
    **							   queued due to orderly
    **							   shutdown in prog. */
    	    srv_log_shell_msg (MODULE_NAME,
    			       SRV_MSG_SEVERITY_W,
    			   "New request rejected during orderly shutdown from ",
    			       (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    	    check_flag = FALSE;				/* Stop message check */
    	    queue_flag = FALSE;				/* Don't queue req. */
    	}						/* End if term. mode */
    
    /*
    ** If the queue is full, then don't try to queue request. If the requestor is
    ** continuing the dialog, return error code SRV_EC_QF (Queue full). Bump the
    ** count of rejected requests due to queue full (SRV_EC_QF_CNT), and inform the
    ** system in any case.
    */
    	if ((check_flag) &&
    	    (srv_queue_cnt >= srv_queue_mrec))
    	{						/* If queue full */
    	    if (((cont_code & SRV_IR_ICB) != 0) ||
    		((cont_code & SRV_IR_IQB) != 0) ||
    		((cont_code & SRV_IR_ODB) != 0))
    	    {						 /* If cont. dialog */
    		send_buf.qhead_str.cont_code = SRV_EC_QF; /* Queue full */
    		send_buf.qhead_str.data_len = 0;	 /* No data */
    
    		if (! srv_write_mbx (&read_buf->qhead_str,
    				     &send_buf,
    				     srv_in_node,
    				     srv_in_mbx,
    				     FALSE,
    				     TRUE,
    				     TRUE))
    		{					/* If send error */
    		    srv_log_shell_msg (MODULE_NAME,
    				       SRV_MSG_SEVERITY_E,
    				       "Error returning EC_QF to ",
    				      (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    		}					/* End if send error */
    	    }						/* End if cont dialog */
    
    	    srv_ec_qf_cnt++;				/* Count of requests not
    **							   queued due to queue
    **							   full */
    	    srv_time (&srv_last_qf_ts);			/* Track time of
    **							   occurance */
    	    srv_log_shell_msg (MODULE_NAME,
    			       SRV_MSG_SEVERITY_E,
    			       "New request rejected due to queue full from ",
    			       (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    	    check_flag = FALSE;				/* Stop message check */
    	    queue_flag = FALSE;				/* Don't queue req. */
    	}						/* End if queue full */
    
    /*
    ** If the enqueue validation routine pointer is not null, then perform the
    ** validation check. If this fails, don't queue the request. If the requestor
    ** is continuing the dialog, return error code SRV_EC_VF (Validation failed).
    ** Bump the count of rejected requests due to failed validation
    ** (SRV_EC_VF_CNT), but don't inform the system.
    */
    	if ((check_flag) &&
    	    (srv_enqueue_routine != NULL) &&
    	    (! ((*srv_enqueue_routine) (&srv_proc_cnt,
    					read_buf))))
    	{						/* If failed validate */
    	    cont_code = read_buf->qhead_str.cont_code;	/* Re-check  code */
    
    	    if (((cont_code & SRV_IR_ICB) != 0) ||
    		((cont_code & SRV_IR_IQB) != 0) ||
    		((cont_code & SRV_IR_ODB) != 0))
    	    {						 /* If cont. dialog */
    		send_buf.qhead_str.cont_code = SRV_EC_VF; /* Validate failed */
    		send_buf.qhead_str.data_len = 0;	 /* No data */
    
    		if (! srv_write_mbx (&read_buf->qhead_str,
    				     &send_buf,
    				     srv_in_node,
    				     srv_in_mbx,
    				     FALSE,
    				     TRUE,
    				     TRUE))
    		{					/* If send error */
    		    srv_log_shell_msg (MODULE_NAME,
    				       SRV_MSG_SEVERITY_E,
    				       "Error returning EC_VF to ",
    				      (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    		}					/* End if send error */
    	    }						/* End if cont dialog */
    
    	    srv_ec_vf_cnt++;				/* Bump count of
    **							   requests that have
    **							   failed validation */
    	    check_flag = FALSE;				/* Stop message check */
    	    queue_flag = FALSE;				/* Don't queue req. */
    	}						/* End if validation
    **							   failed */
    
    /*
    ** If the requestor wants to be informed of queue insertion, then
    ** inform with SRV_RR_RQ. If an error occurs sending the message,
    ** then don't queue it.
    */
    	if ((check_flag) &&
    	    ((cont_code & SRV_IR_IQB) != 0))
    	{						/* If inf. upon queue */
    	    send_buf.qhead_str.cont_code = SRV_RR_RQ;	/* Request queued */
    	    send_buf.qhead_str.data_len = 0;		/* No data */
    
    	    if (! srv_write_mbx (&read_buf->qhead_str,
    				 &send_buf,
    				 srv_in_node,
    				 srv_in_mbx,
    				 FALSE,
    				 TRUE,
    				 TRUE))
    	    {						/* If send error */
    		srv_log_shell_msg (MODULE_NAME,
    				   SRV_MSG_SEVERITY_E,
    				   "Error returning RR_RQ to ",
    				   (struct SRV_QUEUE_HEAD_STRUC *) read_buf);
    							/* Inform */
    		queue_flag = FALSE;			/* Don't queue reqest */
    	    }						/* End if send error */
    	}						/* End if inf. on que */
    
    /*
    ** If queue_flag is still true, insert the new request into the queue,
    ** considering priority
    */
    	if (queue_flag)
    	{						/* If queue request */
    	    srv_queue_req (read_buf);			/* Queue it */
    	}
    
    /*
    ** We have handled the last message. Now, check for and process any new
    ** messages that may be queued in the MBX.
    */
    	if (! srv_read_mbx (srv_read_buf,
    			    &srv_mbx_in_chan,
    			    srv_queue_data_len,
    			    &new_msg,
    			    TRUE,
    			    TRUE))
    	{						/* If read error */
    	    srv_logmesg (srv_proc_name,
    			 MODULE_NAME,
    			 SRV_MSG_SEVERITY_F,
    			 SRV_STAT_NORMAL,
    			 "Error in SRV_READ_MBX (nowait) - terminating");
    	    exit (SRV_BAD_EXIT_STATUS);			/* Inform, terminate */
    	}						/* End if read error */
    
    	if (! new_msg)
    	{						/* If no new message */
    	    break;					/* Exit loop */
    	}						/* End if no new msg. */
    
        }							/* Bottom of do while */
    
    /*
    ** There are no more messages. Queue up the next read, wake up the
    ** server shell to process any possibly queued requests, and return from
    ** AST state.
    */
    
    #ifndef	SRV_PLT_NT
    
        if (! srv_read_mbx_ast ((void *) srv_ast,
    			    TRUE))
        {
    	srv_logmesg (srv_proc_name,
    		     MODULE_NAME,
    		     SRV_MSG_SEVERITY_A,
    		     SRV_STAT_NORMAL,
    		     "Error in SRV_READ_MBX_AST - terminating");
    	exit (SRV_BAD_EXIT_STATUS);			/* Terminate */
        }							/* End if read error */
    
    #endif
    
        srv_wake ();					/* Wake up srv shell */
    
    /*
    ** All done. Return from AST state.
    */
        return;						/* Return from AST */
    }

  9. #69
    Quote Originally Posted by Geo Kaplan View Post
    Tragic. It does no such thing. Why do you think it does?



    Part of the problem -- and it's a deep one -- is that you seem not to understand what science is and what it does. So far you have 5 pages of code, but not a single quantitative result to show that your code correctly describes how the universe works (as evidenced by the vast body of experimental results accumulated over the centuries).

    My single page of code has produced precisely the same volume of relevant output as your 5, and I have yet to write my single page of code.

    So until you've done the actual work of reconciling experiment with the predictions of your simulation, it's rather premature to crow (in caps and boldface, no less) that you have achieved anything, let alone some deep insight into the workings of the universe. At this point, your code and mine are functionally equivalent. The hard work is yet to come for you. The "brain burp" part is easy, and that's all you seem to have so far. Until you've done that hard work, I'm sticking with nanognomes. Maybe they're on a grid, but it's nanognomes all the way down.
    I understand your position. Let me show you. Give me a couple of days. Meanwhile, if anyone has any doubt about my abilities, look at the last post, and marvel at my talent. That's just a sample... I design this stuff as well as write the stupid code. BUT I take pride in my code and I know what I'm doing... I HAVE REASONS FOR everything, especially trying to keep the program extremely small and fguring t out on my own... I have SOLID reasons, not wishy-washy for this!! OK?

    I'm taking a huge longshot putting 4 man years into this project without pay, I have a righteous purpose for doing it as well. I have a visualization... you guys need to understand.. I can see the whole thing operasting.. it didnt just come to me. The way I program is this: 80% planning, 20% implementing. I will tear though this code and show y'all excatly what I'm talking about OK?

    Thanks for your comments.

  10. #70
    Join Date
    Oct 2010
    Posts
    136
    OK, so 14 years ago you have written some code that isn't likely to end up in The Daily WTF. What does that have to do with your ability to actually model physical systems? As has been said several times already in this thread, the first step for you would be to show that your model produces matches to observations in some test cases.

  11. #71
    Join Date
    May 2009
    Location
    28°10'30"N 16°44'31"W
    Posts
    2,248
    Quote Originally Posted by Marty Wollner View Post
    I'm taking a huge longshot putting 4 man years into this project without pay.
    I think a better investment would have been four years at a university. Huge longshots are by definition almost always a failure.

  12. #72
    Hot damn!

    I went though almost every module and found no floating points.. ALL INTEGERS... I love it...

    I'm not working right now, I'm all worried about everyone thinking I don't know how to line up my code... like I'm SUCH an amature, I dont EVEN know how even do THAT!!

    HONESTLY, now,

    Did you guys ever see such attention to detail in your entire lives? I typed every one of those lines out by hand before we had visual studio and VB to line it all up for me. I sat there with the 4-spaces and tab keys on an old VT-100 teminal making sure EVERY one of those nestings line up PERFECTLY. DAMN this is such a sore nerve for me.

    Likewise, like I haven't studied relativity in 400 level physics classes at MSU... like I'm completely unaware of any of the newer theories of cosmolgy, like I dont know about hawking and rips in black holes and dark mattter and anti-matter and all of the other phoney ** these guys dreamed up. yes i dont belive in it, and im out to prove it and a whole lot more. And if YOU ALL wouldm look at some of today's insigts on this, it might allow YOU to see the light, as it were. On my website I state that some of todays acclaimed scientists are approchng a 50% CERTAINTY that YOU are living in a computer simulation RIGHT NOW.

    But boy, was I ever worried about the code linning up. THAT is what's really important.

    Sorrry for the rant , just give me a weeee bit of respect...slam my theories, knock down my ideas, blast my (as yet unasnwered) new questions about relativity, and keep ignoring my basic permace that its digtial and none of your rules apply here, BUT PLEASE, PLEASE don't knock my perfect nesting!!!!

    Do you know I drove to Alaska while on-the-job getting paid to just be there wth a modem and a laptop in case any errors did occur to my bulletproof code?

    THREE DIFFERENT TIMES I said I need a vacation and they begged me to just carry the laptop, a total of 10 1/2 months on the road. AND I WAS A CONTRACTOR! The guys at Ford believed that I could do anything. I spent 14 years there I mst have done something. I'm now trying to do the impossible in the only way I think is possible.

    Hey enough talk just gimme a few days a I will show you ok? thanks!

    AND, now that I have figured out how to use the [code] flags, who knows what I'm really capable of!


    NO, really,...

    On a serious note, I want to start a new discussion thread about the next step in my master plan, and this answers why i demand the program can be kept small and simple.

    I will fill you in later, its pretty cool and provides a possible answer to an impossible question. Here's a big clue... lay this (photo below of the Prime Spiral) over the grid and you get a discrete set of conduits and pathways.,.. circuits as it were... capable of executing small limited "physical calculations (adding machine - shaped patways in virtual motion)" on an imaginary flow of data insipred by the geometry of the cube, when stretched and allowed too recoil. Im suggesting here that there may be just such a combination of "geometric configuration" as it were, to allow the numerical structure of the univerwse itself to actully perform a sequnetial set of calculations. If you study the way LADDER diagrams work (used in industrail contrllers), they look very much like this:


    2 3 5 7

    11 13

    17 19

    23

    29 31

    37

    41 43

    ...

    let's give an interpretation to the rungs, like 1 = and gate, 2 nand gate, 3 = or gate, etc.


    OK NOW, we have a narturally supplied string of numbers being injected into just the right set of logic, and it behaves as the CPU of the Universe.


    IT ONLY NEEDS A SIMPLE PROGRAM TO THEN CREATE A VIRTUAL REALITY EXACTLY like mi... oooooooppppppps gotta keep it scientific!

    Do you guys see where I'm going with this NOW ??? That's why I'm trying to figure it out as something very small, something that just makes stuff go through the motions of what we do observe. BUT AS SIMPLE AS POSSIBLE because if it needs to be reasonably complex, that cuts down on the likelyhood of it ever occuring in the first place. UNDERSTAND?? Its GOT to be simple!

    This is the stuff I been thinking about for the past couple of years.

    First I need the formula, or better yet a bunch of them.

    Then I need to compress then each into a small "circuit", something based upon its geomerty of numbers.

    When I get a few thousand of them, I can actuallly perform a search through each of those finite entry points in the finite list of configurations (it doesnt need to be limited to a cube and to 3-d, and btw, there are no restrictions on my program ... it works in 17 dimensions too.

    Anyway, I can go on testing, in an analytic manner, as a search for the source of the |spark of existence". These are all finite combinations of shapes, "virtual circuits", and "virtual paths of data flow" that occur naturally in our number system.

    So I am suggesting its possible that THAT is the "virtual CPU" that runs the theroy of everything.TWO QUESTIONS, PLEASE AND I WILL SHUT UP:

    Is this explanation somewhat rooted in science?

    Does anyone have a better explanation?
    Attached Thumbnails Attached Thumbnails Click image for larger version. 

Name:	PrimeSpiral_1.jpg 
Views:	221 
Size:	52.7 KB 
ID:	15952  
    Last edited by Marty Wollner; 2011-Dec-13 at 07:26 PM.

  13. #73
    Quote Originally Posted by Marty Wollner View Post
    While you were answering me, i finished and published my new book and now have 1/2 he C version done. I take it as personal insult to hear anyone say that my code is poorly formatted, give me two days thats all. I will show you. OK?
    It's a statement of plain objective fact. The code you'd posted wasn't so much poorly formatted as essentially unformatted. Not a single line was indented. From appearances, in all your vast experience as a programmer, you've never even encountered the CODE tag, or even the concept of formatting code for readability. Not exactly the best presentation to make.

    The sample you posted recently is much better. A formatting convention I hate, but it has one and adheres to it. You could have saved some time by making sure to do this from the start.


    Quote Originally Posted by Marty Wollner View Post
    check out "Flat out disproving relativity in 120 minutes" right now.

    http://spikersystems.com/FlashNet_Po...120Minutes.htm
    No. You were supposed to do that here, and claimed you would. Instead you posted a long-winded spiel that wandered around, proclaimed your greatness some, and turned out in the end to be founded on an incorrect assumption, that the motion of light's emitter was added to its own velocity.


    Quote Originally Posted by Marty Wollner View Post
    If you look thorough the table of contents, you will find many of your answers, escpecially the "disclaimer" section...
    http://spikersystems.com/FlashNet_Po...#_Toc311503675
    Again, you can not link to external sites as your explanation. There's good reasons for putting large amounts of code off-site on something like CodePad or a project hosting service like GitHub or Google Code, but I'm not following these other links.


    Quote Originally Posted by Marty Wollner View Post
    I can answer all of your questions as well, and,
    and while we're at it, check out how my 5 pages of code answers all of THESE questions as well:

    http://spikersystems.com/FlashNet_Po...#_Toc305761053

    gotta scoot, i need to find a c compiler, all i got is this stupid pidgeon...
    Where is the code? I see a near endless mess of grandiose claims and "I am great" statements, aimless sidetracks, random unrelated pictures, and similar dross of no use to me. Signal to noise ratio = abysmally low.

    How about answering some of my questions now?

  14. #74
    Quote Originally Posted by cjameshuff View Post
    It's a statement of plain objective fact. The code you'd posted wasn't so much poorly formatted as essentially unformatted. Not a single line was indented. From appearances, in all your vast experience as a programmer, you've never even encountered the CODE tag, or even the concept of formatting code for readability. Not exactly the best presentation to make.

    The sample you posted recently is much better. A formatting convention I hate, but it has one and adheres to it. You could have saved some time by making sure to do this from the start.
    Now you’re being childish about it. LOOK at that GOL DERN code… LOOK through all of those modules YOU WILL NEVER IN YOUR ENTIRE LIFE SEE CODE THAT CLEAN EVER, NO MATTER WHAT. Did you see the comments, the flow, the cohesiveness? The fact that it was my baby since inception for 14 years as a consultant in a field where such careers averages only 2 months?

    NOOOO Your too busy reminding me how out of touch I am because I don’t know about the stupid freeking code flag on this bb?

    Woooow.

    And you got the nerve to suggest to ME to “do it right in the first place? I supervised 35 programmers at one point. I got into a dozen fist fights with coders who strayed from my strict adhesion to the comments, in fact I had one of my newbies write an automatic comments extractor from the code and auto-generate our 1,000 page systems programming guides directly from the comments and this depended upon consistency and the use of meta flags in the comment headers.

    Who dreamt that one up? The dude who BRAGGED ABOUT INVENTING Double buffering… when I said it’s a common data collection technique? Did I say I invented it?
    Do I act like a snob in any of my work? Is any of my work even directed towards anyone at any really high levels? Do I profess to be smarted that I admit I am NOT?

    What’s your problem anyway? You seem to go out of your way to make it like a personal attack, not a scientific discussion.

    I know at this point you have a slightly higher opinion of me than the default “your an blundering idiot who doesn’t even know what nesting is”, but when I explain what happened between VB and the BB and you still keep on with it now for the 5th time,

    Wait, have I said anything inconsistent here?

    Screw it, I gotta get back to work.

    Thanks for your “constructive comments” about code syntax, and no I don’t want to answer your heckling questions any more, even if you grow up. For Christ’s sake!

  15. #75
    Join Date
    Oct 2009
    Posts
    1,410
    Quote Originally Posted by Marty Wollner View Post
    What’s your problem anyway? You seem to go out of your way to make it like a personal attack, not a scientific discussion.
    Ahem. Self-awareness check time. Look over your own posts. Compute the percentage of sentences dedicated to extolling the manifold virtues of your ideas, skills and achievements. At the same time, compute the percentage of sentences in which you describe actual, quantitative results of your predictions and compare these with experiment.

    In science, as in the rest of society, deportment matters. In science, more perhaps than in the rest of society, those with a large bluster-to-achievement ratio are going to attract harsh attention. If you don't like it, simply dial down the bluster, and dial up the science. Simple.

  16. #76
    Quote Originally Posted by amazeofdeath View Post
    OK, so 14 years ago you have written some code that isn't likely to end up in The Daily WTF. What does that have to do with your ability to actually model physical systems? As has been said several times already in this thread, the first step for you would be to show that your model produces matches to observations in some test cases.
    Thanks for that + comment. I'm on it, the code, the simulation... BUT, I didn't really start this thread to proove my model worked, I started it to introduce the questions about the speed of light, and other than a couple of insulting remarks about the syntax of my auto-reformatted psedocode, I have yet to hear anyone really refute it, other than to remind me of the "reality" of the observations that eveyone knows.

    They were absolutly certain in 1491 that the world was flat. OK?

    The reason that relativity was invented was to explain the speed of light. I have explained it in a much much simpler, much more straightforward mechanism and I think someone needs to invetigate it.

    Now THAT part of my stuff, I dont think the burdon should fall upon me to proove, I already did so in my hypothesis and clearly demostrated it with a numercial analysis. The scaling DOES occur because of the closed range, but that means having to pause matter in discrete segmets of time, which sounds like "The Matrix, Unleashed" or some such nonsense.

    I would like these particular topics to be directed into a discussion somewhere and handled, but not by me. I wrote the book (draft) "flat out disproving relativity in 120 minutes": its there for the anyone to use however they want it. I never charge money for anything I do whatsoever. So its here for free, and its all i can do; the concept is not hard to understand or replicate, it's very very simple.

    That would leave this forum to discuss the simulation and (I think more importantly), the new area I would like to research, as explained in another long--a sked post, BUT I'm thinkin its really cool to reseach finding the CPU structure hidden in the condiuts of prime numbers that make up our U..


    Thanks again
    marty

    Hey did everybdy seen the 12 page article called Bolt, the wonder dog? It describes a really cheap way to help prove that there is a digital grid that keeps our universe ROCK SOLID... there's your either.. its the grid tself.


    http://spikersystems.com/FlashNet_Po...#_Toc279374249

  17. #77
    Join Date
    Oct 2010
    Posts
    136
    While I applaud the effort from modelling the universe from first principles, your model still has to fit the observed facts to be relevant.

    "They" certainly weren't absolutely certain that the earth was flat in 1491; you can easily find descriptions of Colombo's assumptions on the shape, which were rather more complicated than our current oblate spheroid. Not to mention that the flat earth was shown to be inconsistent with the observations centuries before AD 0, and the flat earth was not in high regard even during the dark ages, as far as the highly educated people were concerned during those times.

  18. #78
    Quote Originally Posted by Perikles View Post
    I think a better investment would have been four years at a university. Huge longshots are by definition almost always a failure.
    I spent closer to 10 man years on another total long shot, and I'm waiting to hear from the US patent office if its gonna be approved yet. If it is, it allows me to license the use of a brand new idea in gaming: You not only get to wager on live dice or wheel spins, you also get to play a whole slew of concurrent games generated (off of fair numerical mappings between them), and GET THIS, it also lets the casinos compete for you business and actually perform live, competeive offferings over the customers and even on a customer-by-customer basis. A casino holding 1,000 players can all play these games all against non-electronic randomizations, you know, real dice and stuff, and the whole thing can be operated by a single -unskilled dealer. I got it running in my living room right now and everyone in the world can play along to the same world-wide roll right now in a live demo. No real money is involved.

    http://spikersystems.com/FlashNet_Po...ive_Gaming.htm

    Now there's a big risk eh? But if this patent flys and if "Competitive gaming malls" are built, and if I get 1/1000th of one percentag of any of that massive money flow, then??

    eh??

    College?

    Im 59 yars old, pal.

  19. #79
    Join Date
    Oct 2009
    Posts
    1,410
    Quote Originally Posted by Marty Wollner View Post
    College?

    Im 59 yars old, pal.
    And thus four years would represent less than 7% of your present age. Doesn't sound too onerous, especially given the intellectual value of the enterprise. You'd be exposed to a vast universe of ideas, which might calibrate you on the magnitude of the task before you.

  20. #80
    Join Date
    Jun 2003
    Location
    SE Michigan
    Posts
    2,885
    Quote Originally Posted by Marty Wollner View Post
    They were absolutly [sic] certain in 1491 that the world was flat. OK?
    Actually, no, they (whoever "they" were) weren't. That's a calumny dreamed up by Washington Irving. Most informed individuals of the time knew that the Earth was a sphere. Columbus was selling the idea that it was smaller than most everyone else thought it was. Lucky for him that the Americas were in the way, or he and his crews never would have made it back.

    (Edit to add: I see that amazeofdeath already covered this. Ah, well.)

    Oh, and about your co-worker, Randy Newton, "a direct descend [sic] of sir Isaac"? If you mean Isaac Newton (1642 (or 1643) to 1727), Randy must have been pulling your leg, since Newton died unmarried and childless, and probably never even... well, you know.

    May I make a suggestion? If you find the posts here distracting, take a few days off from the forum, ask the mods to lock the thread for the time being, and apply yourself to your ideas. Come back when your simulation produces some solid results.

    Fred
    "For shame, gentlemen, pack your evidence a little better against another time."
    -- John Dryden, "The Vindication of The Duke of Guise" 1684

  21. #81
    Join Date
    Mar 2004
    Posts
    17,148
    Quote Originally Posted by Marty Wollner View Post
    check out "Flat out disproving relativity in 120 minutes" right now.
    Okay, I checked it out. I don't see anything that disproves relativity, and frankly, it's almost impossible to read. Could you post your argument here?

    Also, I have to ask you: Is this a joke or attempted parody? If you intend to be serious, you need to rewrite that article. Take out the photos and the side discussion about yourself, and focus on the argument, whatever it is.

    "The problem with quotes on the Internet is that it is hard to verify their authenticity." — Abraham Lincoln

    I say there is an invisible elf in my backyard. How do you prove that I am wrong?

    The Leif Ericson Cruiser

  22. #82
    Quote Originally Posted by Geo Kaplan View Post
    Ahem. Self-awareness check time. Look over your own posts. Compute the percentage of sentences dedicated to extolling the manifold virtues of your ideas, skills and achievements. At the same time, compute the percentage of sentences in which you describe actual, quantitative results of your predictions and compare these with experiment.

    In science, as in the rest of society, deportment matters. In science, more perhaps than in the rest of society, those with a large bluster-to-achievement ratio are going to attract harsh attention. If you don't like it, simply dial down the bluster, and dial up the science. Simple.
    yes and I can respect a comment like that when its worded like that, but he said my code was sloppy, and I have absolutely the cleanest code on the plannet, explained it, showed it (it is awesome isnt it?), and he kept it up... that's being childish and plus he keeps ignoing my basic premese, a discontinuous U. and if either of you guys would, bar NONE approach it like that where the train was stationary for the first 19,997 ticks and then only crept one Grid spot, it would seem obvious to you why we had to invent relativity to compensate for it, because the assumption is the the train did keep on sliding along at a continous rate of 3/20,000 of a "partial grid position" per tick. We beleive that we need to stretch the time / gravity displacement in order to make up for the distance that we think we should have traveled in that time but didnt.

    Can we at least agree that things would be different if it worked in timed pauses vs continous flow? (Yes or no) If YES, there must be a way to proove the results would be the same in the two operational modes then, correct? Let's see you do that... and this is nothing to do with my simulator or my code really, other than the two lines of it where the countdown timer says MOVE 1 GC.

    Is there any way to prove the results would aways be the same?

    The same not beween my #1 and #2 scenarios with riderdude, but between my #2 scenario and the one with relativity, which I never tried? That would be a cool test, I think.

    Id like to see that.


    Anyway, as far as my octopus_3.c program, let me whip it up and see what pops out... I'm betting on the Mona Lisa after 23 gazzilion ticks.

  23. #83
    Quote Originally Posted by amazeofdeath View Post
    While I applaud the effort from modelling the universe from first principles, your model still has to fit the observed facts to be relevant.

    "They" certainly weren't absolutely certain that the earth was flat in 1491; you can easily find descriptions of Colombo's assumptions on the shape, which were rather more complicated than our current oblate spheroid. Not to mention that the flat earth was shown to be inconsistent with the observations centuries before AD 0, and the flat earth was not in high regard even during the dark ages, as far as the highly educated people were concerned during those times.
    OK, yes, and I'm that guy right now trying to wake everyone up from a 100 year sleep brought on by Relativity beliefs.

    Thanks for your comment, as IRrelevant as it seems to me

  24. #84
    Quote Originally Posted by Van Rijn View Post
    Okay, I checked it out. I don't see anything that disproves relativity, and frankly, it's almost impossible to read. Could you post your argument here?

    Also, I have to ask you: Is this a joke or attempted parody? If you intend to be serious, you need to rewrite that article. Take out the photos and the side discussion about yourself, and focus on the argument, whatever it is.
    It is no joke, it is written for the general public to enjoy and learn about.

    I do have a condensed version of just the scenarios, I will try to get to you.

    thanks for taking the time.

  25. #85
    Quote Originally Posted by Marty Wollner View Post
    Thanks for that + comment. I'm on it, the code, the simulation... BUT, I didn't really start this thread to proove my model worked, I started it to introduce the questions about the speed of light, and other than a couple of insulting remarks about the syntax of my auto-reformatted psedocode, I have yet to hear anyone really refute it, other than to remind me of the "reality" of the observations that eveyone knows.
    Again, the poor quality of the pseudocode you provided is a plain fact. Pointing that out is not a personal attack. How about toning down the hysterics and endless bragging about how great a coder you are and try actually addressing the actual issues?

    As for refuting it, you have provided little substantial to work with. Numerous of your claims have been refuted, however, such as the issue around traveling faster than half the speed of light, presence of absolute time and rest frames, your arguments about validity of relativity, etc. Still waiting on you to address the issues raised.


    Quote Originally Posted by Marty Wollner View Post
    They were absolutly certain in 1491 that the world was flat. OK?
    As some others have mentioned, while it may have been a somewhat widespread belief among the uneducated, most with any education on the subject knew better. Columbus was using faulty data/analysis to determine his own figure for Earth's radius, and came up with a number that was far smaller than the accepted values. Those accepted values turned out to be more accurate...Columbus was wrong, and would have died at sea if there wasn't an undiscovered continent halfway between Spain and his intended destination.


    Quote Originally Posted by Marty Wollner View Post
    The reason that relativity was invented was to explain the speed of light. I have explained it in a much much simpler, much more straightforward mechanism and I think someone needs to invetigate it.
    You haven't explained anything yet. Your simulation exhibits a speed of light, fine...so do many other simulations, and purely analytical solutions. Your simulation also exhibits some notable flaws that you haven't addressed except by handwaving. Lack of isotropy, for example...really, don't you think we might have noticed light propagating in cubical waveforms instead of spherical ones?

    Are you even aware that there's other ways to tile volumes? Why not truncated octahedra, or the Weaire–Phelan structure? Or simpler, how about irregular tetrahedra?


    Quote Originally Posted by Marty Wollner View Post
    Now THAT part of my stuff, I dont think the burdon should fall upon me to proove, I already did so in my hypothesis and clearly demostrated it with a numercial analysis. The scaling DOES occur because of the closed range, but that means having to pause matter in discrete segmets of time, which sounds like "The Matrix, Unleashed" or some such nonsense.
    You haven't demonstrated anything yet. And the burden of proof that your simulation has anything at all in common with reality absolutely does fall on you.


    Quote Originally Posted by Marty Wollner View Post
    I would like these particular topics to be directed into a discussion somewhere and handled, but not by me. I wrote the book (draft) "flat out disproving relativity in 120 minutes": its there for the anyone to use however they want it. I never charge money for anything I do whatsoever. So its here for free, and its all i can do; the concept is not hard to understand or replicate, it's very very simple.
    Speaking of which, remember when you were going to disprove relativity here? Why didn't that ever happen? Where's your disproof of relativity?

  26. #86
    Quote Originally Posted by Geo Kaplan View Post
    And thus four years would represent less than 7% of your present age. Doesn't sound too onerous, especially given the intellectual value of the enterprise. You'd be exposed to a vast universe of ideas, which might calibrate you on the magnitude of the task before you.
    Better than the internet? (I do have an undergrad degree from MSU. back in 1976 and 1978 ** in cardiovascular physiology and an almost one in computer science in the school of engineerig.. darn if i can remebrer how to do the do the relativity math for example 3, though....i might have to figure it out in my spare time.

  27. #87
    Join Date
    Mar 2004
    Posts
    17,148
    Quote Originally Posted by Marty Wollner View Post
    It is no joke,
    Okay, then you aren't helping your argument at all. I asked because you said yourself that you had read the crackpot index and had a high score on it. I would think that, if you wanted to be taken seriously, you'd want to make some effort to lower your score. On the other hand, this would make a lot of sense as a joke, deliberately set up to hit the points on the index and to see what kind of reaction you'd get.

    it is written for the general public to enjoy and learn about.
    Then I'd suggest reading some popularized science books and articles for some writing tips. But, whatever audience you're writing for, you need to focus on the subject, clean up the writing, and get rid of the photos unless they are on-topic.


    I do have a condensed version of just the scenarios, I will try to get to you.
    Okay, that could help, but does that include a clear argument against relativity theory? In your article, it looked to me like you had a short discussion of a relativity scenario, and then switched to discussing your simulation idea, but if you had an argument against relativity theory in there, I didn't see it.

    thanks for taking the time.
    You're welcome.

    "The problem with quotes on the Internet is that it is hard to verify their authenticity." — Abraham Lincoln

    I say there is an invisible elf in my backyard. How do you prove that I am wrong?

    The Leif Ericson Cruiser

  28. #88
    Code:
    
    /*
    
    #include <Octopus_3_header_1.h>
    
    
    The new way to implement both slow moving matter and digital radiation, by example: 
    
    We will use our “inversion counters” (countdown counters that let stuff sit still and synch with everything in the Universe around it PERFECTLY) for radiation nearly exactly like the way we use them to move matter.
    
    These examples only show the processing for one-dimension (d = 1); this can be done in any additional number of dimensions[8].
    
    The new way to move slow matter, by example
     
    Here is an example of the pseudo-code used
    to move a VP (loaded into the VP list record
    structure X) sitting at location 23,000 at a
    rate of “20”. The velocity number “20”
    obviously gets scaled into our WordSize to
    make things work.
    
    Marty Wollner, 14-Dec-2011, first time
    coding C in many years and loving the living
    the **** out of it, WHAT WAS I THINKING???
    
    This is going to be fun and a SNAP because I
    have this entire thing visualized already.
    
    like, TOTALLY !!!
    
    The first thing is to just go directly into
    the final cut mode right here and now, no
    more micky mouse VB, and no more choice of
    options.
    
    
    I plan to get VB to generate this program as output by allowing the player to pre-select everything, and have it spit out as this SIMPLE-*** C module.
    
    
    It gets compiled and run, and thus run directly for the reqested specified.
    
    The code implements the player's calls DIRECTLY as blood-RAW C, no ifs in this code about the choice of operation or parameterization or scalabilikity.
    
    
    I eventually plan to hook this into my gaming architecture for simultanious broadcasts over CallLucy. I will simply make this code a callable module from
    SRV_LIB as my transaction request, one for each tick in the U.
    
    BTW, my frist book from waaaay back claims that I can multi-task this **** if I keep it all clean... lets see, mo-fo!!!
    
    */
    
    /*
     
    
    The following 2 declarations are using the only externally defined params.
    The $$varname$ form is intened to be replaced with the cactual code text
    in a generated verion of this simple program.
    
    */
    
    /* General type definitions */
    
    #ifndef BOOLEAN_DEFINED
    typedef	unsigned char	BOOLEAN;
    #define	TRUE	1
    #define	FALSE	0
    #define	BOOLEAN_DEFINED
    #endif
    
    
    /*  this is the meta-code:   #define    cNumberOfDimensions = $$cNumberOfDimensions$ */
    
    #define    cNumberOfDimensions 3 /*(just for now) */
    
    /* This constant holds the number of dimensions this Universe is being implemented in. */
    
    /* #define    cWordSize = $$cWordSize$ */
    
    #define    cWordSize  8
    
    
    /* This constant holds the largest possible number used in any of the integer calculations. */
    /* This example defines it as 2**6400 which is about 1/10 the maximum address-ability */
    /* of the Atari-64, but still way beyond the range of our U. */
    
    
    /*
    Alright now here is how I will make this program have a "Near-infinte" capacity.
    I used to think that was a stupid term, but now i'm not so sure about that,
    with my new the end-of numbers theory.
    
    Anyway, here is how Im gonna do my Variable Length integer format, I'm calling VL_int :
    
    iCurrentSize is the current bitsize count
    ImaxSize is typically the the System-Wide max comp limit
    
    Valueptr is a pointer to a maloched chunk of memory pool,
    
    BUT FOR NOW I'm using a fixed size "pool"
    located within the structure itself. So, for now, I will simple
    point the ValuePtr to the next memory location (where the
    "pool is".
    
    The structure is shown:
    */
    
    struct sVL_Internal {
    
    int iCurrentSize;	/* Bits used thus far */
    int iMaxSize;		/* Typically, cWordSizeMax I reckon */
    long ValueLongTemp;	/* JUST FOR NOW, CJ !!! */
    
    };
    
    /*
    
    The SV_int Error Handler: A cal is avaiable to set the error trap location.
    For now we will just jump into it rather than calling it.
    If null, and an error occurs, it terminates with a printf mesage.
    
    */
    
    int *addrVL_intErrorHandler = {0};	/* Pointer to error handler */
    
    struct sVL_int {
    
    int ValuePtr; 					/* Points to the data storage area.*/
    struct	sVL_Internal VL_Internal;
    
    };
    typedef  struct sVL_int VL_int;
    
    
    /*
    ** VL_int will have a set of functions associaterd with it as well.
    */
    
    /*
    Here is our VP list record structure declaration:
    */
    
    struct sVP_ListSingleDimension {
    		  VL_int	Location;
    		  VL_int	LastLocation;
    		  VL_int	S;
    		  VL_int	Coutdown;
    
    };
    
    
    struct sVP_ListRecord {
    		  struct sVP_ListSingleDimension sVP_SDLoc[cNumberOfDimensions];
    		  struct sVL_int HeatLevel;
    		  struct sVL_int Mass;
    };
    typedef  struct sVP_ListRecord VP_ListRec;
    
    /* Prototypes */
    /* General prototype includes */
    
    #include <ctype.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <time.h>
    
    
    
    /* Marty Prototypes */
    
    BOOLEAN bVL_int_Copy (VL_int *,
    			          VL_int);
    /* Copy VL_int to VL_int */
    
    
    void VL_int_LoadFrom_long (VL_int *,
    	                       long);
    /* Load VL_int from a long */
    
    
    BOOLEAN bVL_int_TestGT (VL_int,
    			            VL_int);
    /* Test if VL_int is Greater Than */
    
    
    BOOLEAN bVL_int_TestEQ (VL_int,
    			            VL_int);
    /* Test if VL_int is EQual to */
    
    
    BOOLEAN bVL_int_TestGE (VL_int,
    			            VL_int);
    /* Test if VL_int is Greater than or Equal to */
    
    
    BOOLEAN bVL_int_TestLT (VL_int,
    			            VL_int);
    /* Test if VL_int is Less Than */
    
    
    BOOLEAN bVL_int_TestLE (VL_int,
    			            VL_int);
    /* Test if VL_int is Less than or Equal to */
    
    BOOLEAN VL_intAdd (VL_int *VL_intTarget,
    				   VL_int VL_Operand1,
    		           VL_int VL_Operand2);
    /* The Add function */
    
    BOOLEAN VL_intMul(VL_int *VL_intTarget,
    				  VL_int VL_Operand1,
    		          VL_int VL_Operand2);
    /* The Multiply function */
    
    BOOLEAN VLi_PowerFrom_l (VL_int *VL_intTarget,
    				         VL_int VL_intBase,
    		                 long lExponent);
    /* The exponent function */
    
    
    BOOLEAN  bForward (VP_ListRec VP_L_CurRec,
    	               int d);
    /* Are we goin' forwards or backwards ?? */
    
    
    /* CJ , If your wndering why iI diddnt just make the VI_int stuff  into a class
    
    
    its because I have none... TTHanks for your inspiration,
    
    YOU MADE the comments section. Actually, your helping me in ways you can't imagine!
    
    THANKS again,
    
    marty
    
    discflicker.com
    
    
    
    /* this was my very first new C code in years!! */
    
    /*
    ** First thing we need to do is establish a way to operate upon huge integers.
    **
    ** We will create our own data type called Very Large int, or VL_int for short.
    **
    ** We will also need to comeup with our own set of operators to add, subtract etc these
    ** new huge integers.
    */
    
    /*
    
    Our first function is BOOLEAN bVL_int_Copy
    
    Copies one VL_int into another, may need to allocate room for the target, so it can fail.
    
    Returns false if an error occured like we couldnt allocate enough memory
    for the target if the source is way bigger,, **** like that...
    
    For now, I'm just going to copy a long to a long, so there can't be an error 
    
    If (too big, then error)  not yet..
    */
    
    BOOLEAN bVL_int_Copy (VL_int *VL_intTarget,
    			          VL_int VL_intSource)
    
    {
    
    	VL_intTarget->VL_Internal = VL_intSource.VL_Internal;
    
    
    	/** Just for now!! We will re-do this stuff in the future.
    	    and it might be posibble to return false */
    
    
    	return TRUE;
    
    }
    
    
    /*
    Next function is VLi_LoadFrom_l used to load a long into a VL_int,
    we'll say it can't fail because the target was already allocated
    and that assumes already saving a long of space.
    
    We won't even bother to deal with a reverse function
    because it mopst likely will be exceeded.
    */
    
    
    void VLi_LoadFrom_l (VL_int *VL_intTarget,
    		             long lInput)
    
    {
    	VL_int	VL_intTemp = {0};	/* Temp used for loading */
    
     	VL_intTemp.VL_Internal.ValueLongTemp = lInput;
    
    	/* Copy into the long in the structure,
    	   don't worry about errors */
    
    	bVL_int_Copy (VL_intTarget,
    			      VL_intTemp);
    }
    
    /* Next function is the greater than comparison operator function,
    this replaces the use of " > ". This cannot fail. */
    
    BOOLEAN bVLi_TestGT (VL_int VL_intFirstOperand,
    					 VL_int VL_intSecondOperand)
    {
    	/* Just for now, but later all we may need to do is go through the array of longs or whatever is internaly used storage and pick 'em off and
    	   make the determinations. In highly optimize versons, some bit-shifting would definately be called for here, but not right yet.. */
    
    	if (VL_intFirstOperand.VL_Internal.ValueLongTemp > VL_intSecondOperand.VL_Internal.ValueLongTemp)
    	{
    		return (TRUE);
    	} else
    	{
    		return (FALSE);
    	}
    
    }
    
    /* Next function is the greater than comparison operator function,
    this replaces the use of " == ". This cannot fail. */
    
    BOOLEAN bVLi_TestEQ (VL_int VL_intFirstOperand,
    					VL_int VL_intSecondOperand)
    {
    	/* Just for now, but later all we may need to do is go through the array of longs or whatever is internaly used storage and pick 'em off and
    	   make the determinations. In highly optimize versons, some bit-shifting would definately be called for here, but not right yet.. */
    
    	if (VL_intFirstOperand.VL_Internal.ValueLongTemp == VL_intSecondOperand.VL_Internal.ValueLongTemp)
    	{
    		return (TRUE);
    	} else
    	{
    		return (FALSE);
    	}
    
    }
    
    
    /*
    Next function is the greater than comparison operator function,
    this replaces the use of " >= ". This cannot fail.
    
    We will simply call the existing bVLi_TestEQ and GT comparison routines,
    so if we need to retro-fit we only need to change a few things.
    */
    
    BOOLEAN bVLi_TestGE (VL_int VL_intFirstOperand,
    					 VL_int VL_intSecondOperand)
    {
    
    	if (bVLi_TestGT (VL_intFirstOperand,
    		             VL_intSecondOperand))
    	{
    		return (TRUE);
    	} else
    	{
    		if (bVLi_TestEQ (VL_intFirstOperand,
    		                 VL_intSecondOperand))
    		{
    			return (TRUE);
    		}
    		{
    			return (FALSE);
    		}
    	}
    }
    
    
    /*
    Next function is the less than comparison operator function,
    this replaces the use of " < ". This cannot fail.
    
    We will simply call the existing bVLi_TestEQ and GT comparison routines,
    so if we need to retro-fit we only need to change a few things.
    */
    
    BOOLEAN bVLi_TestLT (VL_int VL_intFirstOperand,
    					 VL_int VL_intSecondOperand)
    {
    
    	if (bVLi_TestGT (VL_intFirstOperand,
    		             VL_intSecondOperand))
    	{
    		return (FALSE);
    	} else
    	{
    		if (bVLi_TestEQ (VL_intFirstOperand,
    		                 VL_intSecondOperand))
    		{
    			return (FALSE);
    		} else
    		{
    			return (TRUE);
    		}
    	}
    }
    
    /*
    Next function is the less than or equal to
    comparison operator function,
    this replaces the use of " <= ". This cannot fail.
    
    We will simply call the existing bVLi_TestEQ and GT comparison routines,
    so if we need to retro-fit we only need to change a few things.
    */
    
    BOOLEAN bVLi_TestLE (VL_int VL_intFirstOperand,
    					 VL_int VL_intSecondOperand)
    {
    
    	if (bVLi_TestGT (VL_intFirstOperand,
    		             VL_intSecondOperand))
    	{
    		return (FALSE);
    	} else
    	{
    		return (TRUE);
    	}
    }
    
    /*
    Next function is the addition module.
    
    WARNING!!
    
    Be careful not to try overwritting the same
    VL-int, as x = x + 2 would allow.
    
    Do that stuff in 2 steps!
    
    */
    
    BOOLEAN VL_intAdd (VL_int *VL_intTarget,
    				   VL_int VL_Operand1,
    		           VL_int VL_Operand2)
    
    {
    
    /**
    ** For now, just add em!
    **
    */
    	VL_intTarget->VL_Internal.ValueLongTemp = 
    		VL_Operand1.VL_Internal.ValueLongTemp +
    		VL_Operand1.VL_Internal.ValueLongTemp;
    
    }
    
    /*
    Next function is the multiply module.
    
    WARNING!!
    
    Be careful not to try overwritting the same
    VL-int, as x = x * 2 would allow.
    
    Do that stuff in 2 steps!
    
    */
    
    BOOLEAN VL_intMul(VL_int *VL_intTarget,
    				  VL_int VL_Operand1,
    		          VL_int VL_Operand2)
    
    {
    	VL_int *Ptr1VL_int;
    	VL_int *Ptr2VL_int;
    
    	VL_int	VL_intTemp;
    	VL_int	VL_intIndex1;
    	VL_int	VL_intIndex2;
    
    	static BOOLEAN bSubsequent;
    	static VL_int	VL_intTempONE;
    
    
    /*
    ** First time only, load ONE
    */
    	if (!bSubsequent)
    	{ /* First time only */
    		bSubsequent = TRUE;
    
    		VLi_LoadFrom_l (&VL_intTempONE,
    						1); /* $$$ make this a global for everyone to use */
    	}
    
    /*
    ** To keep the processing down, lets
    ** try to figure out the lesser size
    ** operand, and only loop through the
    ** add module THAT many times.
    */
    	if (bVLi_TestGT (VL_Operand1,
    					 VL_Operand2))
    	{ /* One way or another... */
    
    		Ptr1VL_int = &VL_Operand1;
    		Ptr2VL_int = &VL_Operand2;
    		
    		bVL_int_Copy (&VL_intIndex2,
    			          VL_Operand1);
    		
    	} else
    	{
    		Ptr1VL_int = &VL_Operand2;
    		Ptr2VL_int = &VL_Operand1;
    
    		bVL_int_Copy (&VL_intIndex2,
    			          VL_Operand2);
    	}
    
    /*
    load 0 into target
    
    Looping CAN use the c structure for loop:
    
    1) load 0 into index1
    2) compare index2 to index1 (gt)
    3) add one to the value of Index2
       !!! (two step so no overwrite... I suppose I could use a ++ here!)
    
    In the loop, accumulate thus implementing multiplication (I think!!)
    */
    	VLi_LoadFrom_l (VL_intTarget,
    					0); /* Zero the target */
    
    	for ((VLi_LoadFrom_l (&VL_intIndex1,
    					      0));
    		(bVLi_TestGT (VL_intIndex1,
    					  VL_intIndex2));
    		
    			VL_intAdd (&VL_intTemp,
    				       VL_intIndex2,
    		               VL_intTempONE))
    
    			bVL_int_Copy (&VL_intIndex2,
    						  VL_intTemp);
    	{
    		VL_intAdd (VL_intTarget,
    				    *Ptr1VL_int,
    		            *Ptr1VL_int);	/* Accumulate */
    	}
    }
    /*
    Next function is multiplies a VL_int number by
    itself, a specified longword number of times,
    and stores the result in another VL_int.
    
    WARNING!!
    
    Be careful not to try overwritting the same
    VL-int, as x = x + 2 would allow.
    
    Do that stuff in 2 steps!
    
    */
    
    BOOLEAN VLi_PowerFrom_l (VL_int *VL_intTarget,
    				         VL_int VL_intBase,
    		                 long lExponent)
    
    {
    	long	lExponentCopy;
    	VL_int	VL_intTemp = {0};	/* Temp used for loading */
    
    
    	lExponentCopy = lExponent;
    
    	VL_intTarget->VL_Internal.ValueLongTemp = 0;
    
    /*
    Two-step operation so no overwrite !!!!
    */
    
    	for (lExponentCopy = 0; lExponentCopy < lExponent; lExponentCopy++)
    	{
    		VL_intMul (&VL_intTemp,
    				   VL_intBase,
    				   *VL_intTarget);
    
    		bVL_int_Copy (VL_intTarget,
    					  VL_intTemp);
    
    	}
    
    }
    
    /*
    The following simple function is needed to determine a if VP’s current direction is forward or backward.
    We return no motion at all as "Forward" (TRUE).
    */
    
    BOOLEAN  bForward (VP_ListRec VP_L_CurRec,
    	               int d)
    {
    	
    	
    	if( bVLi_TestLE(VP_L_CurRec.sVP_SDLoc[d].Location,
    					VP_L_CurRec.sVP_SDLoc[d].LastLocation))
    	{
    	/* We are going forward) */
    		return (TRUE);
    	} else
    	{
    	/* We are traveling backward */
    		return (FALSE);
    	}
    }

  29. #89
    The above module compiles.


    I been up for 50 hours straight, and look, looky look what I can do when I'm flaming nutty.

    This is a fully functional (self made) library of artithmetic functions that I will use to run my program on with a huge external drive unit.

    I listened to everyone here. I hearn CJ recomend libraries that already do this, even programing languages. THANKS I really appreciate that.

    The reason I chose to stil go ahead with my own is because I need to use the WordSize IMPLICITLY inside of the arithmetic, the least of not which is the error functios, but I also plan on providing a switch that will return results which might not be "arithmetically correct".

    You guys will see it all just like i promised.

    Following is main () with a little more work to go, it runs up until the 10 th executable line or so..


    I gotta unwind down at the casino in detroit... I run up 140 fights of stairs while i bomp from poker room to poker room, basically stealing at only $50 risk per buy-in... later guys, THANKS AGAIN !!!

    marty
    discflicker.com



    Code:
    
    #include "Octopus_3_header_1.h"
    
    main ()
    {
    
    /*
    ** Go ahead and declare the VP list right here.
    */
    
    /**	VP_ListRec VP_list[10000];
    	/* All of the virtual matter in the Universe is right here... THIS IS ONLY FOR THIS DEMO!!!
    	   In the actual program, this data will all be out on external storage, and may be
    	   	VP_ListRec VP_list[pow (2,cWordSize)]; large!!
    		
    		Right now this is 10,000.
    
    
    	*/
    
    
    
    	int d;
    	/* d is the current dimension we are running in */
    
    	int ICurrentSet;
    	/* iCurrentSet is the index of the current set we are running in. If there are more than 2, we will round-riobin through them. */
    
    	VP_ListRec VP_X = {0};
    
    /**	VP_ListRec VP_Y;
    	/* VP_ListRec copies */ 
    
    	VL_int VL_intVelocity1 = {0};
    
    
    /**	VL_int VL_intVelocity2;
    	/* These variables will hold a huge integer number, which is our desired velocity of motion. */
    
    	VL_int VL_intCurrenTick = {0};
    
    	/* This variable will hold a huge integer number, which is our current tick counter. */
    
    	VL_int VL_intTickIndex1 = {0};
    
    
    /***	VL_int VL_intTickIndex2;
    	VL_int VL_intTickIndex3;
    	VL_int VL_intTickIndex4;
    	/* This variable will hold a huge integer number, used as temp counters. */
    
    
    
    
    /*
    ** First thing is we need to come up with our own arithmetic system.
    **
    ** We do not beleive in infinity.
    **
    ** And so, we need to assume that there is an end to numbers.
    **
    ** And if there is an end to nuumbers, then everything MUST
    ** work a bit differently.
    **
    ** For one thing, there is no infinity, so
    ** if we need to, we could COUNT THE NUMBER OF INTEGERS between
    ** zero and infinity, and we would come up with a FINITE, definate number.
    **
    ** LETS call this top integer number MaxIntPossible.
    **
    ** Because we are computer programmers by blood, we think in
    **
    ** Binary terms of addressing, and so, let's introduce a new term:
    **
    ** WordSize
    **
    ** And because we are all programmers, we all know that
    **
    **	2 **WordSize = MaxIntPossible.
    **
    ** We are going to bake this concept into the number system
    ** we will now use.
    **
    ** Up front, this progrm needs to "initailze this number system":
    **
    *** By calling a routine that calculates MaxIntPossible,
    **
    ** WHEN I DO THE CALCULATIONS, I HAVE 2 WAYS OF DOING THEM:
    **
    ** ONE, WHERE I JUST TREAT ALL NUMBERS THE SAME
    ** (actually, the interval BETWEEN the nummbers, and think of the IRONY there),
    **
    ** and THE OTHER, I NEED TO FACTOR OUT THE FRACTIONAL PARTS,
    ** AND I WILL HAVE TO, ON OCCATION, MAKE SOME DESICIONS ON ROUNDING AND THAT WILL CHANGE THINGS!!!
    **
    ** When I calculate using the number 40, i will use it as 40/MaxIntPossible.
    **
    ** In all of these calcultions, I will try to look at things like
    ** The differrence between 2 distances,  and scale THAT to n/MaxIntPossible.
    **
    ** It should also set up the error handler at addrVL_intErrorHandler
    ** to keep things under control.
    **
    */
    
    d = 0;
    /* start in the first dimension */
    
    ICurrentSet = 0;
    /* start in the first set */
    
    
    VLi_LoadFrom_l (&VL_intTickIndex1, 22);
    
    
    VLi_LoadFrom_l (&VL_intTickIndex1, 0);
    
    /* Start out in tick 0 */
    
    
    /*
    ** Ready to run?
    */
    
    
    VLi_LoadFrom_l (&VP_X.sVP_SDLoc[d].Location, 23000);
    /* Initizlize particle X at position 23000 */
    
    VLi_LoadFrom_l (&VP_X.sVP_SDLoc[d].Location, 22980);
    /* Our last position was to the left, 20 grid-coordinates */
    
    VLi_LoadFrom_l (&VL_intVelocity1, 20);
    /* Set our desired velocity number at 20 */
    
    bVL_int_Copy (&VP_X.sVP_SDLoc[d].S,
    	          VL_intVelocity1);
    /* Set our desired velocity number at 20 */
    
    }
    
    
    
    GUYS !!
    
    If you want to run the above, cut it out, it works fine....
    
    
    
    
    
    
    /*
    
    The following code segment shows the 1-d motion of the VP currently loaded into
    VP_ListRecord structure X. This VP will move without being involved in any collisions,
    and without any photons absorbed. As such, it just drifts along with no change in
    velocity. 
    
    */
    
    
    
    
    X.S(d) = (2 ** WordSize) – abs (20)
    
    Rem: We set the slow speed of 20 in the inversion counter this way. We use abs(20) to support negative velocity numbers (don’t ask why just yet).
    
     
    
    X.CountDown(d) = 0
    
    Rem: Intialize the countdown counter
    
     
    
    For Index = 1 to 2**1,000,000
    
    Rem: Lets start looping through 2**1,000,000[10] ticks of time…
    
     
    
    X.CountDown(d) = X.CountDown(d) + 1
    
    Rem: Bump the counter
    
     
    
    If (X.CountDown(d) >= X.S(d)) then
    
    Rem: Countdown expired, let’s move 1 grid-coordinate and reset the counter
    
     
    
    If (Bforward(X)) then
    
    Rem: We determine direction from last_location
    
        XLast.Location(d) = X.Location(d)
    
        X.Location(d) = X.Location(d) + 1
    
        Rem: Move 1 grid-coordinate forward
    
    Else
    
        XLast.Location(d) = X.Location(d)
    
                  X.Location(d) = X.Location(d) – 1
    
                  Rem: Move 1 grid-coordinate backward
    
    Endif
    
     
    
    X.CountDown(d) = 0
    
    Rem: Intialize the countdown counter
    
    Rem: There is no need to reset X.S(d) here
    
     
    
    Endif
    
     
    
    Next Index:

  30. #90
    Quote Originally Posted by Van Rijn View Post
    Okay, then you aren't helping your argument at all. I asked because you said yourself that you had read the crackpot index and had a high score on it. I would think that, if you wanted to be taken seriously, you'd want to make some effort to lower your score. On the other hand, this would make a lot of sense as a joke, deliberately set up to hit the points on the index and to see what kind of reaction you'd get.

    Then I'd suggest reading some popularized science books and articles for some writing tips. But, whatever audience you're writing for, you need to focus on the subject, clean up the writing, and get rid of the photos unless they are on-topic.

    You are SOOO correct about that.. Here I am trying to play captain kangaroo teaching concepts that are elusive.


    I'm sorry, you guys are totally right about that.

    I dont know how else I can prsent it to the public, I feel that is very important to try to give some amount of credibility to what Im saying.

    For the level you guys are at, YES it must look aweful.. I will try in the future to present a "scientfic-only" version of everything.

    I feel really strongly that I do have a (sorry) weird scientific case for what I'm really trying to prove, and that is NOT about any mis-conceptions about the speed of light, and not about proving that my theoery of everything is .

    Its about proving that a very, very simple program, (which can always be "boiled down" (reduced) to a single finite-series equation), (and I'm obviously not the first to think up ), can prove to create somewhat of a presentable universe...

    which can be FULLY described from such a simple formula,

    THIS EQUATION can be made into a PHYSICAL computing geometry.. it can read like a strip of punched paper tape,

    a PHYSICAL CIRCUIT... you know, like how abcuses' work, and how adding machines physically work inside.

    it becomes almost like a piece of DNA with a long coding sequence on it.

    OK NOW, I presented this concept above, referring to the photo of the "prime spiral", and the apparent "condiuts" and "entry points". And I scribbled a bunch of numbers down and said something about LADDER LOGIC and industrial contollers...

    Finally, I started yacking about "natural streams" of sequential numbers that can "feed" an "entry point" in the numeric structure that resuts from the conduits and pathways in the prime spiral.

    Let me tell everyone reading this, what I'm finding in common here:


    How an abcus or and old adding machine ACTUALLY work (a physical computation unit)

    How DNA ACTUALLY works (it carries the long molecule sequences past a "transciption unit")

    How a computer CPU ACTUALLY works (it carries the long instruction sequences past a "physical computation unit" (digitized, yes, but the operational process follows the physical movement of the abcus)

    What I'm tying to suggest about the numerical structure of the universe behaving like a physical processor that runs a very very simple program that creates virtual reality. No god included here, sorry.
    (NOT ON THIS BASIC LEVEL, yet).

    The program can be so simple that the random chance of it and a whole bunch more like it are being run is ???. I think its possible to quantitize the entire study and look for the real combinations of these structures and these programs among the near plethera of numbers we have to look into. We have all the time in the world to look for and find them... the numbers arent going anywhere.
    Last edited by Marty Wollner; 2011-Dec-15 at 04:29 PM.

Similar Threads

  1. Some Strange News... [computer code, string theory]
    By Aethelwulf in forum Science and Technology
    Replies: 55
    Last Post: 2012-May-20, 11:08 AM
  2. Looking For Grapics Tool For Wiki Pages
    By TheHalcyonYear in forum Off-Topic Babbling
    Replies: 6
    Last Post: 2008-Oct-17, 01:21 PM
  3. Tables on Web pages
    By kylenano in forum Off-Topic Babbling
    Replies: 7
    Last Post: 2006-Jan-31, 06:33 PM
  4. 2004 MN4 in the funny pages
    By musasa in forum Astronomy
    Replies: 6
    Last Post: 2006-Jan-09, 03:55 PM
  5. web pages for kids
    By Rob C in forum Astronomy
    Replies: 3
    Last Post: 2002-Jul-02, 10:12 PM

Tags for this Thread

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
here
The forum is sponsored in-part by: