Belum lama ini, diskusi dimulai pada pengenalan denda untuk mempercepat lebih dari 10 km / jam dari yang diizinkan. Secara tradisional, mereka dilakukan secara
tidak konstruktif untuk Internet, jadi saya biasanya tidak mendukung sisi mana pun dari holivar semacam itu.
Argumen pemilik mobil dalam massa direduksi menjadi geraman "Aku butuh", yang, tentu saja, tidak identik. Sebagian besar orang yang dipaksa mengemudi 50 km untuk bekerja setiap hari melalui lokasi yang tidak tercakup oleh angkutan umum tidak kurang dari bagian orang yang bepergian dengan mobil ke "toko roti", yang dapat dilihat dengan jelas oleh mesin-mesin yang ditinggalkan di pagi hari pada saat pertama kali. salju kecil.
Urbanis sering mendengar argumen yang sepihak, contoh-contoh pribadi basi dari negara-negara Eropa, populasi yang kadang-kadang sepenuhnya sebanding dengan lalu lintas harian Moskow, trik seperti klise menghina tentang "truk cepat".
Dan ketika situasi seperti itu terjadi, tidak ada yang lebih baik daripada membuang emosi orang lain dan memanggil dua asisten yang tidak memihak - Matan dan Python.
Kelemahan posisi pemilik mobil - mereka tidak mengedepankan cara untuk menyelesaikan masalah mereka (menurut saya, solusinya adalah menghapuskan pengembangan spontan setiap bidang tanah gratis di kota-kota besar dan mengembangkan daerah sehingga orang tidak harus berurusan dengan migrasi tenaga kerja ke ibukota di negara asal mereka, tetapi siapa saya? seperti menawarkan hal-hal seperti itu?). Urbanis selalu memiliki serangkaian argumen dan solusi turnkey yang didukung oleh data. Tetapi kadang-kadang ini adalah studi dari institusi yang serius, terkadang statistik yang tidak terlalu jelas tanpa penjatahan yang memadai. Data ini dalam banyak kasus mendorong gagasan penurunan kecepatan secara umum di kota-kota. Dan argumen paling umum yang menguntungkannya adalah:
"Ngomong-ngomong, karena lampu lalu lintas, kamu tidak bisa bergerak dengan kecepatan maksimum sepanjang waktu, kecepatan rata-rata kamu akan lebih rendah dari yang diizinkan, jadi mengapa tidak menurunkan sedikit yang diizinkan?""Hmmm," aku selalu memikirkan argumen ini. Jika Anda menurunkan maksimum yang diizinkan, rata-rata juga akan turun sedikit. Dan apa yang dibuktikan ini - bahwa itu dapat dikurangi lagi?
Aporia macam apa ini? Anda perlu memeriksa seberapa benar ini.
Saya ingin memperkenalkan artikel lebih lanjut kepada Anda dengan reservasi untuk mengarahkan kritiknya dalam komentar dengan cara yang konstruktif:
- Ya, saya tahu betapa jeleknya kode ini ditulis, tetapi lebih penting bagi saya bahwa ia bekerja dengan benar, saya sendiri bukan seorang programmer, lebih baik menulis komentar pada kode di PM.
- Ya, saya tahu bahwa simulasi dapat dibuat lebih sulit, lebih penuh dan lebih realistis. Hanya saya tidak akan menerima celaan bahwa tidak ada perubahan dalam kepadatan lalu lintas pada siang hari, dinamika yang berbeda dari mobil yang berbeda, kondisi cuaca,
fase bulan, ibu penulis , tetapi komentar yang masuk akal, indikasi cacat algoritmik, modifikasi model untuk situasi apa pun yang tidak dipertimbangkan. Dalam pemahaman saya, itu sudah cukup untuk menjawab pertanyaan sederhana dari sudut pandang matematika:
mengingat diskresi gerakan yang kuat karena lampu lalu lintas, apakah penurunan kecepatan maksimum yang diizinkan di bagian individu secara signifikan mempengaruhi waktu perjalanan?Inti dari model saya sangat sederhana. Karena lampu lalu lintas adalah siklus program yang sudah jadi, simulasi dibangun di sekitar bagian jalan dengan lampu lalu lintas di ujung dan fase-fase. Iterasi berikutnya adalah langkah selanjutnya dari rute dengan panjangnya, kecepatan yang diizinkan, dan fase lampu lalu lintas di bagian akhir.
Mobil ini memiliki tiga fase gerakan: dipercepat secara seragam, gerakan dengan kecepatan maksimum yang diperbolehkan untuk bagian tertentu, sama lambatnya. Mereka diimplementasikan dalam 9 versi.
- Jika mobil pindah ke bagian saat ini dengan kecepatan yang sama dengan yang diizinkan, maka ia bergerak tanpa perubahan;
- Jika dia bergerak lebih lambat (atau berdiri) - maka dia pertama kali mempercepat;
- Tidak ada pilihan "dia bergerak lebih cepat", dan inilah sebabnya: jika kecepatan yang diizinkan lebih rendah di segmen berikutnya, dia mengurangi kecepatan pada ini. Apakah ini logis?
Lebih banyak opsi ditambahkan ke opsi ini:
- Mobil itu naik saat melaju atau melambat, dan tiba di ujung segmen dengan warna merah. Ini berarti Anda harus berhenti di depan lampu lalu lintas. Dengan asumsi bahwa selalu melambat dengan akselerasi yang sama, kami menunda jalur yang diperlukan untuk pengereman dari lampu lalu lintas. Ini adalah jarak kritis, dengan analogi dengan kecepatan take - off kritis pesawat. Sekarang, jika, sesuai dengan kondisi, mobil melewati lampu merah, itu harus mulai melambat ke nol, mulai dari titik kritis;
- Sial, atau mungkin segmennya begitu pendek atau mobilnya sangat sayur sehingga tidak punya waktu untuk mengambil kecepatan maksimum sebelum Skrit dimulai? Dan program baganet, terus membubarkannya, meskipun sudah waktunya baginya untuk memperlambat di depan lampu lalu lintas? Jika ini terjadi, kami akan memaksanya untuk tidak menambah kecepatan lebih tinggi dari yang dicapai pada titik Scrit, dan kemudian kami akan menerapkan salah satu opsi. Inilah hasilnya:
Dan kemudian Anda perlu mengimplementasikan ini dalam kode. Inilah yang saya lakukan, memberikan komentar terinci:
Pola agama Hinduimport 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% .
, (, ), — .