Vor nicht allzu langer Zeit begannen die Diskussionen über die Einführung einer Geldbuße für eine Geschwindigkeit von mehr als 10 km / h. Traditionell werden sie
unkonstruktiv für das Internet durchgeführt, daher unterstütze ich im Allgemeinen keine Seite solcher Holivars.
Die Argumente der Autobesitzer in der Masse werden auf Knurren "Ich brauche" reduziert, die natürlich nicht identisch sind. Ein erheblicher Teil der Menschen, die gezwungen sind, täglich 50 km zur Arbeit durch Orte zu fahren, die nicht mit öffentlichen Verkehrsmitteln abgedeckt sind, macht nicht weniger als den Anteil der Menschen aus, die mit dem Auto zur „Bäckerei“ reisen, was genau an diesen Maschinen deutlich zu sehen ist, die am Morgen stehen wenig Schnee.
Urbanisten hören oft eher einseitige Argumente, abgedroschene private Beispiele europäischer Länder, deren Bevölkerung manchmal völlig mit dem täglichen Moskauer Verkehr vergleichbar ist, Tricks wie beleidigende Klischees über „schnelles Trucking“.
Und wenn eine solche Situation eintritt, gibt es nichts Besseres, als die Emotionen anderer Menschen fallen zu lassen und zwei unparteiische Assistenten hinzuzuziehen - Matan und Python.
Schwäche der Position der Autobesitzer - sie schlagen keine Wege vor, um ihre Probleme zu lösen (meiner Meinung nach wäre die Lösung, die spontane Entwicklung jedes freien Landstücks in Großstädten abzuschaffen und Regionen zu entwickeln, damit sich die Menschen nicht mit Arbeitsmigration in die Hauptstadt ihres Heimatlandes befassen müssen, sondern wer bin ich wie solche Dinge anzubieten?). Urbanisten haben immer eine Reihe von Argumenten und schlüsselfertigen Lösungen, die auf Daten beruhen. Aber manchmal sind dies Studien seriöser Institutionen, manchmal nicht sehr verständliche Statistiken ohne angemessene Rationierung. Diese Daten sprechen in den meisten Fällen für eine allgemeine Geschwindigkeitsabnahme in Städten. Und das häufigste Argument für sie ist:
"Wegen der Ampeln können Sie sich nicht immer mit maximaler Geschwindigkeit bewegen. Ihre Durchschnittsgeschwindigkeit ist niedriger als die zulässige. Warum also nicht die leicht zulässige Geschwindigkeit senken?""Hmmm", dachte ich immer an dieses Argument. Wenn Sie das maximal zulässige Maß senken, sinkt auch der Durchschnitt leicht. Und was beweist das - dass es wieder reduziert werden kann? Was für eine
Aporia ist das? Sie müssen überprüfen, wie wahr dies ist.
Ich möchte Ihnen mit Vorbehalt einen weiteren Artikel vorstellen, um seine Kritik in den Kommentaren konstruktiv zu lenken:
- Ja, ich weiß, wie hässlich der Code geschrieben ist, aber es ist wichtiger für mich, richtig zu arbeiten. Ich bin selbst kein Programmierer und schreibe Kommentare zum Code in PM.
- Ja, ich weiß, dass die Simulation schwieriger, vollständiger und realistischer gestaltet werden könnte. Aber ich werde keine Vorwürfe akzeptieren, dass sich die Verkehrsdichte tagsüber nicht ändert, unterschiedliche Dynamiken verschiedener Autos, Wetterbedingungen,
Mondphasen, die Mutter des Autors , aber vernünftige Bemerkungen, Hinweise auf algorithmische Fehler, Modelländerungen für nicht berücksichtigte Situationen. Nach meinem Verständnis reicht es aus mathematischer Sicht aus, eine einfache Frage zu beantworten:
Beeinflusst die Abnahme der maximal zulässigen Geschwindigkeit in einzelnen Abschnitten angesichts der starken Diskretion der Bewegung aufgrund von Ampeln die Fahrzeit erheblich?Die Essenz meines Modells ist sehr einfach. Da es sich bei der Ampel um einen vorgefertigten Programmzyklus handelt, wird die Simulation um einen Straßenabschnitt mit einer Ampel am Ende und ihren Phasen erstellt. Die nächste Iteration ist die nächste Etappe der Route mit ihrer Länge, zulässigen Geschwindigkeit und der Ampelphase am Ende.
Das Auto hat drei Bewegungsphasen: gleichmäßig beschleunigt, Bewegung mit der für einen bestimmten Abschnitt zulässigen Höchstgeschwindigkeit, gleich langsam. Sie sind in 9 Versionen implementiert.
- Wenn sich das Auto mit der gleichen Geschwindigkeit, die es zulässt, zum aktuellen Abschnitt bewegt, bewegt es sich ohne Änderungen.
- Wenn er sich langsamer bewegte (oder stand) - dann beschleunigt er zuerst;
- Es gibt keine Option „er bewegte sich schneller“, und deshalb: Wenn die zulässige Geschwindigkeit im nächsten Segment niedriger ist, reduziert er die Geschwindigkeit dafür. Ist es logisch?
Zu diesen Optionen werden weitere Optionen hinzugefügt:
- Das Auto fährt, während es fährt oder langsamer wird, und kommt am Ende des Segments in Rot an. Dies bedeutet, dass Sie vor einer Ampel anhalten müssen. Unter der Annahme, dass es immer mit der gleichen Beschleunigung langsamer wird, verschieben wir den Weg, der zum Bremsen an der Ampel erforderlich ist. Dies ist die kritische Entfernung in Analogie zur kritischen Startgeschwindigkeit von Flugzeugen. Wenn das Auto nun gemäß den Bedingungen durch ein rotes Licht fährt, sollte es ab dem kritischen Punkt auf Null langsamer werden.
- Verdammt, oder vielleicht ist das Segment so kurz oder das Auto ist so pflanzlich, dass es vor dem Einsetzen von Skrit keine Zeit hat, die Höchstgeschwindigkeit zu erreichen? Und das Programm Baganet, das es weiter zerstreut, obwohl es Zeit für ihn ist, vor einer Ampel langsamer zu werden? In diesem Fall werden wir ihn zwingen, keine höhere Geschwindigkeit als die am Punkt Scrit erreichte zu erreichen, und dann werden wir eine der Optionen implementieren. Hier ist das Ergebnis:
Und dann müssen Sie dies in Code implementieren. So habe ich es gemacht und detaillierte Kommentare abgegeben:
Hinduismus-Musterimport random
import math
# :
redlight = ("100",
"10",
"90",
"1", # "-" . . 1
"1") # 1 , 0. . .
# :
greenlight = ("30",
"120",
"30",
"1",
"1")
# :
distance = ("400",
"400",
"250",
"500",
"500")
#
velocity = ("60",
"60",
"60",
"60",
"40")
#-
r=0
g=0
d=0
v=0
# :
vcurrent=float(0)
# :
t=0
# :
gtime=0
#, 100 / 15 .
# :
accel=float(100/(3.6*15))
#, .
# :
decel = float(accel*2)
# , ( , 0):
while r<=2:
red=float(redlight[r])
grn=float(greenlight[g])
dis=float(distance[d])
vel=float(float(velocity[v])/3.6)
vnext=float(float(velocity[v+1])/3.6)
# accel :
#saccel = float(((vcurrent*vel-vcurrent)/accel) + ((vel-vcurrent)*((vel-vcurrent)/(2*accel)
saccel = float((vcurrent*(vel-vcurrent)/accel) + (vel-vcurrent)*(vel-vcurrent)/(2*accel))
# : , decel:
scrit = float(dis-(vel/decel) - (vel*vel)/(2*decel))
# , .
# :
startingred = random.randint(0, (int(grn)-1))
print ("startingred= ", startingred)
# , __ - :
if vcurrent == vel:
# , , :
if vnext>= vcurrent:
t = int (dis/vel)
# , :
if (t+startingred)%(red+grn)<=red:
t = int (scrit/vel + (vel/decel) + red-((t+startingred)%(red+grn))) ### 2
vcurrent = 0
print (" , ")
# , :
else:
t = int (dis/vel)### 1
vcurrent = vel
print (" , ", " v=", vcurrent)
# , , scrit:
else:
t = int ((scrit/vel) +
(vcurrent - (vnext)/((vcurrent*(vcurrent - (vnext/(dis-scrit))-
((vcurrent - vnext)*(vcurrent - vnext)/(2*(dis-scrit))))))))
# , :
if (t+startingred)%(red+grn)<=red:
t = int (scrit/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 2
vcurrent = 0
print (" , ")
# - , , scrit :
else:
t = int (scrit/vel +
(vcurrent - vnext)/((vcurrent*(vcurrent - (vnext/(dis-scrit))-
((vcurrent - vnext)*(vcurrent - vnext)/(2*(dis-scrit)))))))### 3
vcurrent = float(vnext/3.6)
print (" , ", " v=", vcurrent)
# , __ - :
elif vcurrent < vel:
# , scrit:
vcrit=math.sqrt(2*accel*scrit+vcurrent*vcurrent)
# scrit, scrit, vcrit , :
if saccel >= scrit:
# - ,
if vnext >= vcrit:
t = int(((vcrit-vcurrent)/ accel) + (dis-scrit)/vcrit)
# , :
if (t+startingred)%(red+grn)<=red:
t = int(((vcrit-vcurrent)/ accel) + ((dis-scrit)*2/vcrit) + red-((t+startingred)%(red+grn)))### 8
vcurrent = 0
print (" , , ")
# , :
else:
t = int(((vcrit-vcurrent)/ accel) + (dis-scrit)/vcrit) ### 7
vcurrent = vcrit
print (" , , ", " v=", vcurrent)
# -
else:
t = int(((vcrit-vcurrent)/ accel) + (vcrit - vnext)/((vcrit*(vcrit - vnext)/(dis-scrit))-
((vcrit - vnext)*(vcrit - vnext)/(2*(dis-scrit)))))
# , :
if (t+startingred)%(red+grn)<=red:
t = int(((vcrit-vcurrent)/ accel) + ((dis-scrit)*2/vcrit) + red-((t+startingred)%(red+grn)) ) ### 8
vcurrent = 0
print (" , , ")
# - , , scrit :
else:
t = int(((vcrit-vcurrent)/ accel) + (vcrit - vnext)/((vcrit*(vcrit - vnext)/(dis-scrit))-
((vcrit - vnext)*(vcrit - vnext)/(2*(dis-scrit))))) ### 9
vcurrent = vnext
print (" , , ", " v=", vcurrent)
# scrit, , :
else:
# , , :
if vnext>= vel:
t = int(((vel- vcurrent)/accel) + (dis-saccel)/vel)
# , :
if (t+startingred)%(red+grn)<=red:
t = int (((vel- vcurrent)/accel) + (scrit-saccel)/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 5
vcurrent = 0
print (" , ")
# , :
else:
t = int (((vel- vcurrent)/accel) + (dis-saccel)/vel)### 4
vcurrent = vel
print (" , ", " v=", vcurrent)
else:
# , :
if (t+startingred)%(red+grn)<=red:
t = int (((vel- vcurrent)/accel) + (scrit-saccel)/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 5
vcurrent = 0
print (" , ")
# - , , scrit :
else:
print ("scrit ", scrit)
print ("vcurrent ", vcurrent)
t = int (((vel- vcurrent)/accel) +(scrit-saccel)/vel + (vel - vnext)/((vel*(vel - vnext)/(dis-scrit))-((vel - vnext)*(vel - vnext)/(2*(dis-scrit))))) ### 6
vcurrent = vnext
print (" , ", " v=", vcurrent)
# , __ - , :
else:
print ("ERROR: v current > v next")
print (t)
r+=1
g+=1
d+=1
v+=1
gtime+=t
print (gtime)
.
0 100 15 , . , — , .
, , , . , — , . , 3-5 . , , — , . …
, . , . . — .
, . , , , . , : , . — ( ). , , :
t = int (scrit/vel + (vel/decel) + red-((t+startingred)%(red+grn)) <b>+ (red+grn)</b>)
- ? , , , . . , , / .
, , ? .
, . , . , , , , .
. , , , , 10000 :
import random
import math
n=0
overalltime=0
while n<=10000:
redlight = ("100",
"10",
"90",
"20",
"60",
"20",
"20",
"20",
"20",
"60",
"20",
"20",
"90",
"90",
"100",
"60",
"100",
"80",
"80",
"60",
"90",
"60",
"120",
"60",
"80",
"60",
"1",
"1")
greenlight = ("30",
"120",
"30",
"120",
"40",
"120",
"120",
"120",
"120",
"40",
"120",
"120",
"40",
"15",
"20",
"20",
"20",
"20",
"20",
"40",
"30",
"20",
"40",
"40",
"20",
"40",
"1",
"1")
distance = ("400",
"400",
"250",
"250",
"250",
"450",
"300",
"650",
"1000",
"450",
"500",
"900",
"450",
"400",
"1100",
"900",
"600",
"1000",
"450",
"450",
"400",
"450",
"200",
"500",
"350",
"400",
"500",
"500")
velocity = ("80",
"80",
"80",
"80",
"80",
"80",
"60",
"80",
"80",
"80",
"80",
"80",
"80",
"80",
"80",
"80",
"80",
"60",
"80",
"80",
"80",
"80",
"80",
"60",
"80",
"80",
"80",
"40")
r=0
g=0
d=0
v=0
vcurrent=float(0)
t=0
gtime=0
accel=float(100/(3.6*15))
decel = float(accel*2)
while r<=26:
red=float(redlight[r])
grn=float(greenlight[g])
dis=float(distance[d])
vel=float(float(velocity[v])/3.6)
vnext=float(float(velocity[v+1])/3.6)
saccel = float((vcurrent*(vel-vcurrent)/accel) + (vel-vcurrent)*(vel-vcurrent)/(2*accel))
scrit = float(dis-(vel/decel) - (vel*vel)/(2*decel))
startingred = random.randint(0, (int(grn)-1))
if vcurrent == vel:
if vnext>= vcurrent:
t = int (dis/vel)
if (t+startingred)%(red+grn)<=red:
t = int (scrit/vel + (vel/decel) + red-((t+startingred)%(red+grn))) ### 2
vcurrent = 0
else:
t = int (dis/vel)### 1
vcurrent = vel
else:
t = int ((scrit/vel) +
(vcurrent - (vnext)/((vcurrent*(vcurrent - (vnext/(dis-scrit))-
((vcurrent - vnext)*(vcurrent - vnext)/(2*(dis-scrit))))))))
if (t+startingred)%(red+grn)<=red:
t = int (scrit/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 2
vcurrent = 0
else:
t = int (scrit/vel +
(vcurrent - vnext)/((vcurrent*(vcurrent - (vnext/(dis-scrit))-
((vcurrent - vnext)*(vcurrent - vnext)/(2*(dis-scrit)))))))### 3
vcurrent = float(vnext/3.6)
elif vcurrent < vel:
vcrit=math.sqrt(2*accel*scrit+vcurrent*vcurrent)
if saccel >= scrit:
if vnext >= vcrit:
t = int(((vcrit-vcurrent)/ accel) + (dis-scrit)/vcrit)
if (t+startingred)%(red+grn)<=red:
t = int(((vcrit-vcurrent)/ accel) + ((dis-scrit)*2/vcrit) + red-((t+startingred)%(red+grn)))### 8
vcurrent = 0
else:
t = int(((vcrit-vcurrent)/ accel) + (dis-scrit)/vcrit) ### 7
vcurrent = vcrit
else:
t = int(((vcrit-vcurrent)/ accel) + (vcrit - vnext)/((vcrit*(vcrit - vnext)/(dis-scrit))-
((vcrit - vnext)*(vcrit - vnext)/(2*(dis-scrit)))))
if (t+startingred)%(red+grn)<=red:
t = int(((vcrit-vcurrent)/ accel) + ((dis-scrit)*2/vcrit) + red-((t+startingred)%(red+grn)) ) ### 8
vcurrent = 0
else:
t = int(((vcrit-vcurrent)/ accel) + (vcrit - vnext)/((vcrit*(vcrit - vnext)/(dis-scrit))-
((vcrit - vnext)*(vcrit - vnext)/(2*(dis-scrit))))) ### 9
vcurrent = vnext
else:
if vnext>= vel:
t = int(((vel- vcurrent)/accel) + (dis-saccel)/vel)
if (t+startingred)%(red+grn)<=red:
t = int (((vel- vcurrent)/accel) + (scrit-saccel)/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 5
vcurrent = 0
else:
t = int (((vel- vcurrent)/accel) + (dis-saccel)/vel)### 4
vcurrent = vel
else:
if (t+startingred)%(red+grn)<=red:
t = int (((vel- vcurrent)/accel) + (scrit-saccel)/vel + (vel/decel)+ red-((t+startingred)%(red+grn)))### 5
vcurrent = 0
else:
t = int (((vel- vcurrent)/accel) +(scrit-saccel)/vel + (vel - vnext)/((vel*(vel - vnext)/(dis-scrit))-((vel - vnext)*(vel - vnext)/(2*(dis-scrit))))) ### 6
vcurrent = vnext
else:
print ("ERROR: v current > v next")
#print (t)
r+=1
g+=1
d+=1
v+=1
gtime+=t
dev=(1476-gtime)*(1476-gtime)
#print (gtime)
n+=1
dev+=dev
overalltime+=gtime
print ("mean= ", overalltime/n)
print ("deviation= ", math.sqrt(dev/n))
« » — , .
: 10 /, , 50 /.
10 000 , raw data:
(, /; , ; ):
90 1466,6 0,5
80 1475,6 0,4
70 1479,7 0,9
60 1593,7 0,8
50 1701,3 0,5
40 1869,8 0,6
. , , Y , .
. -,
. - 70 / . -, , 8% 13% « ». ,
, , . , , «» 10% .
, (, ), — .