इतना समय पहले नहीं, अनुमति से 10 किमी / घंटा से अधिक की गति से जुर्माना लगाने की चर्चा शुरू हुई थी। परंपरागत रूप से, उन्हें इंटरनेट के लिए असंवैधानिक रूप से संचालित किया जाता है, इसलिए मैं आमतौर पर ऐसे होलीवर्स के किसी भी पक्ष का समर्थन नहीं करता हूं।
द्रव्यमान में कार मालिकों के तर्क "मुझे ज़रूरत है" को कम करने के लिए कम कर दिए जाते हैं, जो निश्चित रूप से समान नहीं हैं। उन लोगों के लिए एक महत्वपूर्ण अनुपात जो हर दिन उन स्थानों के माध्यम से काम करने के लिए 50 किमी ड्राइव करने के लिए मजबूर किया जाता है जो सार्वजनिक परिवहन खाते द्वारा कवर नहीं किए जाते हैं, जो कार द्वारा यात्रा करने वाले लोगों के हिस्से से कम नहीं है, जो कि "बेकरी" के लिए कार से यात्रा करते हैं, जो कि इन मशीनों को सुबह सबसे पहले देखा जा सकता है। थोड़ी बर्फ।
शहरी लोग अक्सर एक तरफा तर्क सुनते हैं, यूरोपीय देशों के हैक किए गए निजी उदाहरणों को हैक करते हैं, जिनमें से आबादी कभी-कभी पूरी तरह से दैनिक मॉस्को ट्रैफ़िक की तुलना में होती है, "त्वरित ट्रकिंग" के बारे में क्लिच का अपमान करने जैसी चालें।
और जब ऐसी स्थिति होती है, तो अन्य लोगों की भावनाओं को छोड़ने और दो निष्पक्ष सहायकों - मैटन और पायथन को कॉल करने से बेहतर कुछ नहीं होता है।
कार मालिकों की स्थिति की कमजोरी - वे अपनी समस्याओं को हल करने के लिए आगे के तरीके नहीं रखते हैं (मेरी राय में, समाधान बड़े शहरों में भूमि के प्रत्येक मुक्त पैच के सहज विकास को समाप्त करना होगा और क्षेत्रों को विकसित करना होगा ताकि लोगों को अपने मूल देश में पूंजी के लिए श्रम प्रवास से निपटना न पड़े, लेकिन मैं कौन हूं? इस तरह की चीजों की पेशकश के रूप में?)। शहरी लोगों के पास डेटा द्वारा समर्थित तर्कों और टर्नकी समाधानों का एक सेट होता है। लेकिन कभी-कभी ये गंभीर संस्थानों के अध्ययन होते हैं, कभी-कभी पर्याप्त राशन के बिना बहुत समझदार आंकड़े नहीं होते हैं। ज्यादातर मामलों में ये आंकड़े शहरों में गति में सामान्य कमी के विचार को धक्का देते हैं। और उसके पक्ष में सबसे आम तर्क है:
"वैसे भी, ट्रैफिक लाइट्स के कारण, आप हर समय अधिकतम गति से आगे नहीं बढ़ सकते हैं, आपकी औसत गति अनुमति से कम होगी, इसलिए थोड़ी कम की अनुमति क्यों नहीं?""हम्म्म," मैंने हमेशा इस तर्क के बारे में सोचा। यदि आप अधिकतम अनुमत कम करते हैं, तो औसत भी थोड़ा गिर जाएगा। और यह क्या साबित करता है - कि इसे फिर से कम किया जा सकता है? यह किस तरह का
एपोरिया है ? आपको यह जांचने की आवश्यकता है कि यह कितना सच है।
मैं अपनी आलोचना को रचनात्मक तरीके से टिप्पणी करने के लिए आरक्षण के साथ एक और लेख प्रस्तुत करना चाहूंगा:
- हां, मुझे पता है कि कोड कितना बदसूरत है, लेकिन यह मेरे लिए अधिक महत्वपूर्ण है कि यह सही ढंग से काम करता है, मैं खुद एक प्रोग्रामर नहीं हूं, पीएम में कोड पर टिप्पणी लिखना बेहतर है।
- हां, मुझे पता है कि सिमुलेशन को अधिक कठिन, पूर्ण और अधिक यथार्थवादी बनाया जा सकता है। लेकिन मैं इस बात को स्वीकार नहीं करूंगा कि दिन के दौरान ट्रैफ़िक घनत्व में कोई बदलाव नहीं हुआ है, अलग-अलग कारों की अलग-अलग गतिशीलता, मौसम की स्थिति,
चंद्रमा के चरण, लेखक की मां , लेकिन समझदार टिप्पणी, एल्गोरिदम संबंधी खामियों के संकेत, किसी भी स्थिति में मॉडल संशोधनों पर विचार नहीं किया गया है। मेरी समझ में, यह गणित के दृष्टिकोण से एक साधारण प्रश्न का उत्तर देने के लिए पर्याप्त है:
ट्रैफिक लाइट के कारण आंदोलन की मजबूत असंगति को देखते हुए, क्या व्यक्तिगत वर्गों में अधिकतम अनुमत गति में कमी यात्रा के समय को काफी प्रभावित करती है?मेरे मॉडल का सार बहुत सरल है। चूंकि ट्रैफिक लाइट एक तैयार-निर्मित कार्यक्रम चक्र है, इसलिए सिमुलेशन सड़क के एक हिस्से के चारों ओर अंत में ट्रैफिक लाइट और उसके चरणों में बनाया गया है। अगला पुनरावृत्ति इसकी लंबाई, अनुमत गति और अंत में ट्रैफ़िक लाइट चरण के साथ मार्ग का अगला पैर है।
कार के तीन चरण होते हैं: समान रूप से गति, किसी दिए गए सेक्शन के लिए अधिकतम गति के साथ गति, समान रूप से धीमी गति से। वे 9 संस्करणों में कार्यान्वित किए जाते हैं।
- यदि कार उसी गति के साथ वर्तमान अनुभाग में चली गई, जिस पर उसे अनुमति दी जाती है, तो वह बिना बदलाव के चलती है;
- यदि वह धीमा (या खड़ा) चला गया - तो वह पहले तेजी लाता है;
- "वह तेजी से आगे बढ़ रहा था" कोई विकल्प नहीं है, और यही कारण है कि: यदि अगले खंड में अनुमत गति कम है, तो वह इस गति को कम कर देता है। क्या यह तर्कसंगत है?
इन विकल्पों में अधिक विकल्प जोड़े गए हैं:
- यह सवारी के रूप में सवारी या विघटित हो जाती है, और लाल सेगमेंट के अंत में आ जाती है। इसका मतलब है कि आपको ट्रैफिक लाइट के सामने रुकना होगा। यह मानते हुए कि यह हमेशा एक ही त्वरण के साथ धीमा हो जाता है, हम ट्रैफिक लाइट से ब्रेक लगाने के लिए आवश्यक पथ को स्थगित कर देते हैं। यह महत्वपूर्ण दूरी है, समालोचना द्वारा विमान की महत्वपूर्ण गति से दूर । अब, यदि, स्थितियों के अनुसार, कार लाल बत्ती से गुजरती है, तो इसे महत्वपूर्ण बिंदु से शुरू होकर शून्य तक धीमा करना चाहिए;
- धिक्कार है, या हो सकता है कि सेगमेंट इतना छोटा हो या कार इतनी सब्ज़ी वाली हो कि उसके पास स्किट की शुरुआत से पहले अधिकतम गति लेने का समय न हो? और कार्यक्रम बैगनेट, इसे फैलाने के लिए जारी है, हालांकि यह उसके लिए एक ट्रैफिक लाइट से पहले धीमा होने का समय है? यदि ऐसा होता है, तो हम उसे मजबूर कर देंगे कि वह पॉइंट स्क्रिट पर हासिल की गई गति से अधिक न उठाए, और फिर हम विकल्पों में से एक को लागू करेंगे। यहाँ परिणाम है:
और फिर आपको इसे कोड में लागू करने की आवश्यकता है। मैंने इसे कैसे किया, यह विस्तृत टिप्पणी प्रदान करता है:
हिंदू धर्म का पैटर्नimport 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% .
, (, ), — .