LÖVE

Thustrust wrote:You should try to get it to calculate and draw a maximum number of lines per frame so there's no lag and the detail can be as large as you want. Rather than doing all operations in a single "frame" which gets exponentially more computationally intensive, maybe you could just run through a set number of lines in each frame. That way the fractal would slowly draw itself and the program wouldn't hang.

Would that work?

0x69 wrote:1. Lets say fractal is drawn from some table fractal = {x1,y1,x2,y2,x3,y3,...}. After calculating next fractal stage - fractal table is erased and re-inserted all new fractal points (Now it is like that). To be able to do like you say, we should change that table dynamically, -> remove some points then add some points. This means that there will be needed :
- length_of_fractal_table number of deletes from fractal table
- inserts into fractal table must be performed not at the end of table, but everywhere (in start of table, somewhere in between of table, etc.)

0x69 wrote:2. Lets just pretend that everyhing went fine - your proposal will just let us see *intermediate* calculation steps, but total time of fractal computation will not decrease. I think this is crucial. What user will do with unfinished intermediate fractal ? I mean that implementation of such thing will not give us any striking advantage. (Striking advantage would be if we manage to shorten total computation time, or lets say somehow add color effects on fractal

Robin wrote: Is it even necessary to remove points? All points at generation n still exist in generation n+1, right?

Robin wrote: There is one definite advantage to showing intermediate steps: for people, perceived time is more important than real time, and showing something in between will help to decrease the first.

0x69 wrote:You may be right, but now I don`t have any wish to implement *nice switch between fractal stages*. I better focus on my new projects

Robin wrote:

0x69 wrote:You may be right, but now I don`t have any wish to implement *nice switch between fractal stages*. I better focus on my new projects

Good. It would be a shame if you wouldn't do anything new.

local times=80000
function InsertInTheEnd()
	local t={}
	for i=1,times do
		table.insert(t,1)
	end
end
function InsertInBetween()
	local t={}
	for i=1,times do
		table.insert(t,math.random(1+#t),1)
	end
end
t1=os.clock()
	InsertInTheEnd()
t2=os.clock()
	InsertInBetween()
t3=os.clock()
print("Insertion of "..times.." elements:\n",
	t2-t1.." sec. => In the end of table\n",
	t3-t2.." sec. => Somewhere in between of table",
	"\nSlowDown is => "..math.floor((t3-t2)/(t2-t1)).."x")

Insertion of 80000 elements:
0.031 sec. => In the end of table
29.344 sec. => Somewhere in between of table
SlowDown is => 946x

0x69 wrote:

Code: Select all

function InsertInTheEnd()
	local t={}
	for i=1,times do
		table.insert(t,1)
	end
end
function InsertInBetween()
	local t={}
	for i=1,times do
		table.insert(t,math.random(1+#t),1)
	end
end

1. Get global "math".
2. Get field "random".
3. Get length of t.
4. Add it to 1.
5. Call a field.

function InsertInTheEnd()
	local t={}
	for i=1,times do
		math.random(1+#t)
		table.insert(t,1)
	end
end
function InsertInBetween()
	local t={}
	for i=1,times do
		table.insert(t,math.random(1+#t),1)
	end
end

Robin wrote: Maybe this would give fairer results:

Code: Select all

function InsertInTheEnd()
	local t={}
	for i=1,times do
		math.random(1+#t)
		table.insert(t,1)
	end
end
function InsertInBetween()
	local t={}
	for i=1,times do
		table.insert(t,math.random(1+#t),1)
	end
end

anjo wrote:Hey, relax. No one's refusing to accept your argument. Robin just wanted to make sure to remove all outside influences from the results, to ensure that they're completely legitimate. Otherwise, they could be skewed by some irrelevant factor and undermine your hypothesis. I think that's reasonable to do.