Il n'y a pas si longtemps, des discussions ont commencé sur l'introduction d'une amende pour excès de vitesse de plus de 10 km / h par rapport à la vitesse autorisée. Traditionnellement, ils sont menés de manière
non constructive pour Internet, donc je ne soutiens généralement aucun côté de ces holivars.
Les arguments des propriétaires de voitures dans la masse se réduisent à des grondements "j'ai besoin", qui, bien entendu, ne sont pas identiques. Une proportion importante de personnes qui sont obligées de parcourir chaque jour 50 km pour se rendre au travail dans des endroits non couverts par les transports en commun ne représentent pas moins que la part des personnes qui se rendent en voiture à la «boulangerie», ce qui se voit clairement dans ces mêmes machines qui ont été laissées à la maison le premier peu de neige.
Les urbanistes entendent souvent des arguments plutôt unilatéraux, des exemples privés de pays européens dont la population est parfois entièrement comparable au trafic quotidien de Moscou, des astuces comme des clichés insultants sur le «camionnage rapide».
Et quand une telle situation se produit, il n'y a rien de mieux que de laisser tomber les Ă©motions des autres et de faire appel Ă deux assistants impartiaux - Matan et Python.
Faiblesse de la position des propriétaires de voitures - ils ne proposent pas de moyens pour résoudre leurs problèmes (à mon avis, la solution serait d'abolir le développement spontané de chaque parcelle de terrain gratuite dans les grandes villes et de développer des régions afin que les gens n'aient pas à faire face à la migration de main-d'œuvre vers la capitale dans leur pays d'origine, mais qui suis-je comme offrir de telles choses?). Les urbanistes ont toujours un ensemble d'arguments et de solutions clé en main appuyés par des données. Mais parfois ce sont des études d'institutions sérieuses, parfois des statistiques peu intelligibles sans rationnement adéquat. Ces données poussent dans la plupart des cas l'idée d'une diminution générale de la vitesse dans les villes. Et l'argument le plus courant en sa faveur est:
"De toute façon, à cause des feux de circulation, vous ne pouvez pas vous déplacer à la vitesse maximale tout le temps, votre vitesse moyenne sera inférieure à celle autorisée, alors pourquoi ne pas baisser légèrement la vitesse autorisée?""Hmmm", j'ai toujours pensé à cet argument. Si vous abaissez le maximum autorisé, la moyenne diminuera également légèrement. Et qu'est-ce que cela prouve - qu'il peut être réduit à nouveau? De quel genre d'
aporie s'agit- il? Vous devez vérifier à quel point cela est vrai.
Je voudrais vous présenter un autre article avec des réserves afin de diriger sa critique dans les commentaires de manière constructive:
- Oui, je sais Ă quel point le code est moche, mais il est plus important pour moi qu'il fonctionne correctement, je ne suis pas moi-mĂŞme programmeur, il vaut mieux Ă©crire des commentaires sur le code en PM.
- Oui, je sais que la simulation pourrait être rendue plus difficile, plus complète et plus réaliste. Mais je n'accepterai pas les reproches selon lesquels il n'y a pas de changement dans la densité du trafic pendant la journée, la dynamique différente des différentes voitures, les conditions météorologiques, les
phases de lune, la mère de l'auteur , mais des remarques sensées, des indications de défauts algorithmiques, des modifications de modèle pour toutes les situations non prises en compte. À mon avis, il suffit de répondre à une question simple du point de vue des mathématiques:
étant donné la forte discrétion des mouvements dus aux feux de circulation, la diminution de la vitesse maximale autorisée dans les sections individuelles affecte-t-elle considérablement le temps de trajet?L'essence de mon modèle est très simple. Comme le feu de circulation est un cycle de programme prêt à l'emploi, la simulation est construite autour d'une section de la route avec un feu de circulation à la fin et ses phases. L'itération suivante est l'étape suivante de l'itinéraire avec sa longueur, sa vitesse autorisée et la phase des feux de circulation à la fin.
La voiture a trois phases de mouvement: uniformément accélérée, mouvement avec la vitesse maximale autorisée pour une section donnée, tout aussi lent. Ils sont implémentés en 9 versions.
- Si la voiture s'est déplacée vers la section actuelle à la même vitesse que celle autorisée, elle se déplace sans changement;
- S'il se déplaçait plus lentement (ou se tenait) - alors il accélère d'abord;
- Il n'y a pas d'option «il se déplaçait plus vite», et c'est pourquoi: si la vitesse autorisée est inférieure dans le segment suivant, il réduit la vitesse sur ce point. Est-ce logique?
Plus d'options sont ajoutées à ces options:
- La voiture roule en roulant ou en décélérant et arrive à la fin du segment en rouge. Cela signifie que vous devez vous arrêter devant un feu de circulation. En supposant qu'il ralentisse toujours avec la même accélération, nous reportons la trajectoire nécessaire au freinage au feu. Il s'agit de la distance critique, par analogie avec la vitesse critique de décollage des avions. Maintenant, si, selon les conditions, la voiture passe par un feu rouge, elle devrait commencer à ralentir à zéro, à partir du point critique;
- Merde, ou peut-être que le segment est si court ou que la voiture est si végétale qu'elle n'a pas le temps de prendre la vitesse maximale avant le début de Skrit? Et le programme baganet, continue de le disperser, bien qu'il soit temps pour lui de ralentir devant un feu de circulation? Si cela se produit, nous le forcerons à ne pas accélérer plus vite que celui atteint au point Scrit, puis nous mettrons en œuvre l'une des options. Voici le résultat:
Et puis vous devez implémenter cela dans le code. Voici comment je l'ai fait, en fournissant des commentaires détaillés:
Motif de l'hindouismeimport 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% .
, (, ), — .