Anylogic Variable Not Updating - simulation
I an using a discrete event simulator in AnyLogic. I am having an issue with some code which updates a variable in my simulation. I store both the datetime at which the agent leaves the source block and the datetime at which it enters the sink block. I am trying to record the number of "rule breaks" for all agents. The rule break is defined below (two ways to break):
1) If the agent is received before a certain time (called SDC) and the agent is not completed by 5pm the same day, then the agent has broken the rule
2) If the agent is not completed by the next day at a certain time (called NDC), then the agent has broken the rule
I record a zero or a one for each agent if they break either rule in the variable called RuleBreak. However, in my simulation runs, the variable does not update at all. I hope I am just missing something small. Would appreciate any help! (code below)
Calendar received = Calendar.getInstance();
received.setTime(ReceivedDate);
Calendar completion = Calendar.getInstance();
completion.setTime(Completion);
Calendar SD_at_5 = Calendar.getInstance();
SD_at_5.setTime(ReceivedDate);
SD_at_5.set(Calendar.HOUR_OF_DAY,17);
SD_at_5.set(Calendar.MINUTE, 0);
SD_at_5.set(Calendar.SECOND, 0);
Calendar Tomorrow_at_NDC = Calendar.getInstance();
Tomorrow_at_NDC.setTime(ReceivedDate);
if(Tomorrow_at_NDC.get(Calendar.DAY_OF_WEEK) == 6)
Tomorrow_at_NDC.add(Calendar.DATE, 3);
else
Tomorrow_at_NDC.add(Calendar.DATE, 1);
Tomorrow_at_NDC.add(Calendar.DATE, 1);
Tomorrow_at_NDC.set(Calendar.HOUR_OF_DAY,NDC);
Tomorrow_at_NDC.set(Calendar.MINUTE, 0);
Tomorrow_at_NDC.set(Calendar.SECOND, 0);
int Either_rule_break = 0;
double time_diff_SDC = differenceInCalendarUnits(TimeUnits.SECOND,completion.getTime(),SD_at_5.getTime());
double time_diff_NDC = differenceInCalendarUnits(TimeUnits.SECOND,completion.getTime(),Tomorrow_at_NDC.getTime());
if((received.get(Calendar.HOUR_OF_DAY) < SDC) && (time_diff_SDC <= 0))
Either_rule_break = Either_rule_break + 1;
else
Either_rule_break = Either_rule_break + 0;
if((received.get(Calendar.HOUR_OF_DAY) >= SDC) && (time_diff_NDC <= 0))
Either_rule_break = Either_rule_break + 1;
else
Either_rule_break = Either_rule_break + 0;
if((Either_rule_break >= 1))
RuleBreak = RuleBreak + 1;
else
RuleBreak = RuleBreak + 0;
You haven't really explained where this code is used and what it receives. I assume the code is in a function, called in the sink's on-enter action, where ReceivedDate and Completion are Date instances stored per agent (source exit time and sink entry time, as dates, captured via AnyLogic's date() function).
And looks like your SDC hour-of-day is stored in SDC and your NDC hour-of-day in NDC (with RuleBreak being a variable in Main or similar storing the total number of rule-breaks).
Your calculations look OK except that the Tomorrow_at_NDC Calendar calculation seems wrong: you add 1 day twice (if not Saturday) or 3 days plus 1 day (if Saturday; in a Java Calendar, day-of-week 1 is Monday).
(Your Java is also very 'inefficient' with unnecessary extra local variables and performing logic when you don't need to; e.g., no point doing all the calendar preparation and check for your type 1 rule-break if the receive time is after the SDC hour.)
But are you sure there are any rule-breaks; how have you set up your model to ensure that there are (to test it)? Plus is RuleBreak definitely a variable outside of the agents that flow through your DES (i.e., in Main or similar)? Plus are Completion and ReceivedDate definitely stored per agent so, for example, if your function was called checkForRuleBreaks you would be doing something like the below in your sink on-exit action:
agent.Completion = date(); // Agent received date set earlier in Source action
checkForRuleBreaks(agent.ReceivedDate, agent.Completion);
(In fact, you don't need to store the completion date in the agent at all since that will always be the current sim-date inside your function and so you can just calculate it there.)
Related
Decay chain simulation - with significantly different time scales
I would like to simulate a decay chain with Python. Normally, (in a loop over all nuclides) one calculates the number of decays per time step and updates the number of mother and daughter nuclei. My problem is that the decay chain contains half-lives on very different time scales, i.e. 0.0001643 seconds for Po-214 and 307106512477175.9 seconds (= 1600 years) for Ra-226. Using the same time step for all nuclides seems useless. Is there a simulation method, preferably in Python, that can be used to handle this case?
Don't use time steps for this. Use event scheduling. Half lives can be expressed as exponential decay, and the conversion between half life and rate of decay is straightforward. Start with the number of both types of nuclei, and schedule exponential inter-event times to figure out when the next decay of each type will occur. Whichever type has the lower time, decrement the corresponding number of nuclei and schedule the next decay for that type (and if need be, increment the count of whatever it decays into). This can easily be generalized to multiple distinct event types by using a priority queue ordered by time of occurrence to determine which event will be the next one performed. This is the underlying principle behind discrete event simulation. Update This approach works with individual decay events, but we can leverage two important properties when we have exponential inter-event times. The first is to note that exponentially distributed inter-event times means these are Poisson processes. The superposition property tells us that the union of two independent Poisson processes, each having rate λ, is a Poisson process with rate 2λ. Simple induction shows that if we have n independent Poisson properties with the same rate, their superposition is a Poisson process with rate nλ. The second property is that the exponential distribution is memoryless. This means that when a Poisson event occurs, we can generate the time to the next event by generating a new exponentially distributed time at the current rate and adding it to the current time. You haven't provided any information about what you want in the way of output, so I arbitrarily decided to print a report showing the time and the current numbers of nuclides whenever that number was halved. I also printed a report every 10 years, given the long half-life of Po-214. I converted half-lifes to rates using the link provided at the top of the post, and then to means since that's what Python numpy's exponential generator is parameterized to use. That's an easy conversion, since means and rates are inverses of each other. Here's a Python implementation with comments: from numpy.random import default_rng from math import log rng = default_rng() # This creates a list of entries of quantities that will trigger a report. # I've chosen to go with successive halvings of the original quantity. def generate_report_qtys(n0): report_qty = [] divisor = 2 while divisor < n0: report_qty.append(n0 // divisor) # append next half-life qty to array divisor *= 2 return report_qty seconds_per_year = 365.25 * 24 * 60 * 60 po_214_half_life = 0.0001643 # seconds ra_226_half_life = 1590 * seconds_per_year log_2 = log(2) po_mean = po_214_half_life / log_2 # per-nuclide decay rate for po_214 ra_mean = ra_226_half_life / log_2 # ditto for ra_226 po_n = po_n0 = 1_000_000_000 ra_n = ra_n0 = 1_000_000_000 time = 0.0 # Generate a report when the following sets of half-lifes are reached po_report_qtys = generate_report_qtys(po_n0) ra_report_qtys = generate_report_qtys(ra_n0) # Initialize first event times for each type of event: # - first entry is polonium next event time # - second entry is radium next event time # - third entry is next ten year report time next_event_time = [ rng.exponential(po_mean / po_n), rng.exponential(ra_mean / ra_n), 10 * seconds_per_year ] # Print column labels and initial values print("time,po_214,ra_226,time_in_years") print(f"{time},{po_n},{ra_n},{time / seconds_per_year}") while time < ra_226_half_life: # Find the index of the next event time. Index tells us the event type. min_index = next_event_time.index(min(next_event_time)) if min_index == 0: po_n -= 1 # decrement polonium count time = next_event_time[0] # update clock to the event time if po_n > 0: next_event_time[0] += rng.exponential(po_mean / po_n) # determine next event time for po else: next_event_time[0] = float('Inf') # print report if this is a half-life occurrence if len(po_report_qtys) > 0 and po_n == po_report_qtys[0]: po_report_qtys.pop(0) # remove this occurrence from the list print(f"{time},{po_n},{ra_n},{time / seconds_per_year}") elif min_index == 1: # same as above, but for radium ra_n -= 1 time = next_event_time[1] if ra_n > 0: next_event_time[1] += rng.exponential(ra_mean / ra_n) else: next_event_time[1] = float('Inf') if len(ra_report_qtys) > 0 and ra_n == ra_report_qtys[0]: ra_report_qtys.pop(0) print(f"{time},{po_n},{ra_n},{time / seconds_per_year}") else: # update clock, print ten year report time = next_event_time[2] next_event_time[2] += 10 * seconds_per_year print(f"{time},{po_n},{ra_n},{time / seconds_per_year}") Run times are proportional to the number of nuclides. Running with a billion of each took 831.28s on my M1 MacBook Pro, versus 2.19s for a million of each. I also ported this to Crystal, a compiled Ruby-like language, which produced comparable results in 32 seconds for a billion of each nuclide. I would recommend using a compiled language if you intend to run larger sized problems, but I will also point out that if you use half-life reporting as I did the results are virtually identical for smaller population sizes but are obtained much more rapidly. I would also suggest that if you want to use this approach for a more complex model, you should use a priority queue of tuples containing time and type of event to store the set of pending future events rather than a simple list. Last but not least, here's some sample output: time,po_214,ra_226,time_in_years 0.0,1000000000,1000000000,0.0 0.0001642985647308265,500000000,1000000000,5.20630734690935e-12 0.0003286071415481526,250000000,1000000000,1.0412931957694901e-11 0.0004929007624958987,125000000,1000000000,1.5619082645571865e-11 0.0006571750701843468,62500000,1000000000,2.082462133319222e-11 0.0008214861652253772,31250000,1000000000,2.6031325741671646e-11 0.0009858208114474198,15625000,1000000000,3.1238776442043114e-11 0.0011502417677631668,7812500,1000000000,3.6448962144243124e-11 0.0013145712145548718,3906250,1000000000,4.165624808460947e-11 0.0014788866075394896,1953125,1000000000,4.686308868670272e-11 0.0016432124609700412,976562,1000000000,5.2070260760325286e-11 0.001807832817519779,488281,1000000000,5.728676507465013e-11 0.001972981254301889,244140,1000000000,6.252000324175124e-11 0.0021372947080755688,122070,1000000000,6.772678239395799e-11 0.002301139510796509,61035,1000000000,7.29187108904514e-11 0.0024642826956509244,30517,1000000000,7.808840645837847e-11 0.0026302282280720344,15258,1000000000,8.33469030620844e-11 0.0027944471221414947,7629,1000000000,8.855068579808016e-11 0.002954014120737834,3814,1000000000,9.3607058861822e-11 0.0031188370035748177,1907,1000000000,9.882998084692174e-11 0.003282466175503322,953,1000000000,1.0401507641592902e-10 0.003457552492113242,476,1000000000,1.0956322699169905e-10 0.003601851131916978,238,1000000000,1.1413577496124477e-10 0.0037747824699194033,119,1000000000,1.1961563838566314e-10 0.0039512825256332275,59,1000000000,1.252085876503038e-10 0.004124330529803301,29,1000000000,1.3069214800248755e-10 0.004337121375518753,14,1000000000,1.3743508300754027e-10 0.004535068261934763,7,1000000000,1.437076413268044e-10 0.004890820999020369,3,1000000000,1.5498076529965425e-10 0.004909065046898487,1,1000000000,1.555588842908994e-10 315576000.0,0,995654793,10.0 631152000.0,0,991322602,20.0 946728000.0,0,987010839,30.0 1262304000.0,0,982711723,40.0 1577880000.0,0,978442651,50.0 1893456000.0,0,974185269,60.0 2209032000.0,0,969948418,70.0 2524608000.0,0,965726762,80.0 2840184000.0,0,961524848,90.0 3155760000.0,0,957342148,100.0 3471336000.0,0,953178898,110.0 3786912000.0,0,949029294,120.0 4102488000.0,0,944898063,130.0 4418064000.0,0,940790494,140.0 4733640000.0,0,936699123,150.0 5049216000.0,0,932622334,160.0 5364792000.0,0,928565676,170.0 5680368000.0,0,924523267,180.0 5995944000.0,0,920499586,190.0 6311520000.0,0,916497996,200.0 6627096000.0,0,912511030,210.0 6942672000.0,0,908543175,220.0 7258248000.0,0,904590364,230.0 7573824000.0,0,900656301,240.0 7889400000.0,0,896738632,250.0 8204976000.0,0,892838664,260.0 8520552000.0,0,888956681,270.0 8836128000.0,0,885084855,280.0 9151704000.0,0,881232862,290.0 9467280000.0,0,877401861,300.0 9782856000.0,0,873581425,310.0 10098432000.0,0,869785364,320.0 10414008000.0,0,866002042,330.0 10729584000.0,0,862234212,340.0 11045160000.0,0,858485627,350.0 11360736000.0,0,854749939,360.0 11676312000.0,0,851032010,370.0 11991888000.0,0,847329028,380.0 12307464000.0,0,843640016,390.0 12623040000.0,0,839968529,400.0 12938616000.0,0,836314000,410.0 13254192000.0,0,832673999,420.0 13569768000.0,0,829054753,430.0 13885344000.0,0,825450233,440.0 14200920000.0,0,821859757,450.0 14516496000.0,0,818284787,460.0 14832072000.0,0,814727148,470.0 15147648000.0,0,811184419,480.0 15463224000.0,0,807655470,490.0 15778800000.0,0,804139970,500.0 16094376000.0,0,800643280,510.0 16409952000.0,0,797159389,520.0 16725528000.0,0,793692735,530.0 17041104000.0,0,790239221,540.0 17356680000.0,0,786802135,550.0 17672256000.0,0,783380326,560.0 17987832000.0,0,779970864,570.0 18303408000.0,0,776576174,580.0 18618984000.0,0,773197955,590.0 18934560000.0,0,769836170,600.0 19250136000.0,0,766488931,610.0 19565712000.0,0,763154778,620.0 19881288000.0,0,759831742,630.0 20196864000.0,0,756528400,640.0 20512440000.0,0,753237814,650.0 20828016000.0,0,749961747,660.0 21143592000.0,0,746699940,670.0 21459168000.0,0,743450395,680.0 21774744000.0,0,740219531,690.0 22090320000.0,0,736999181,700.0 22405896000.0,0,733793266,710.0 22721472000.0,0,730602000,720.0 23037048000.0,0,727427544,730.0 23352624000.0,0,724260327,740.0 23668200000.0,0,721110260,750.0 23983776000.0,0,717973915,760.0 24299352000.0,0,714851218,770.0 24614928000.0,0,711740161,780.0 24930504000.0,0,708645945,790.0 25246080000.0,0,705559170,800.0 25561656000.0,0,702490991,810.0 25877232000.0,0,699436919,820.0 26192808000.0,0,696394898,830.0 26508384000.0,0,693364883,840.0 26823960000.0,0,690348242,850.0 27139536000.0,0,687345934,860.0 27455112000.0,0,684354989,870.0 27770688000.0,0,681379178,880.0 28086264000.0,0,678414567,890.0 28401840000.0,0,675461363,900.0 28717416000.0,0,672522494,910.0 29032992000.0,0,669598412,920.0 29348568000.0,0,666687807,930.0 29664144000.0,0,663787671,940.0 29979720000.0,0,660901676,950.0 30295296000.0,0,658027332,960.0 30610872000.0,0,655164886,970.0 30926448000.0,0,652315268,980.0 31242024000.0,0,649481821,990.0 31557600000.0,0,646656096,1000.0 31873176000.0,0,643841377,1010.0 32188752000.0,0,641041609,1020.0 32504328000.0,0,638253759,1030.0 32819904000.0,0,635479981,1040.0 33135480000.0,0,632713706,1050.0 33451056000.0,0,629962868,1060.0 33766632000.0,0,627223350,1070.0 34082208000.0,0,624494821,1080.0 34397784000.0,0,621778045,1090.0 34713360000.0,0,619076414,1100.0 35028936000.0,0,616384399,1110.0 35344512000.0,0,613702920,1120.0 35660088000.0,0,611035112,1130.0 35975664000.0,0,608376650,1140.0 36291240000.0,0,605729994,1150.0 36606816000.0,0,603093946,1160.0 36922392000.0,0,600469403,1170.0 37237968000.0,0,597854872,1180.0 37553544000.0,0,595254881,1190.0 37869120000.0,0,592663681,1200.0 38184696000.0,0,590085028,1210.0 38500272000.0,0,587517782,1220.0 38815848000.0,0,584961743,1230.0 39131424000.0,0,582420312,1240.0 39447000000.0,0,579886455,1250.0 39762576000.0,0,577362514,1260.0 40078152000.0,0,574849251,1270.0 40393728000.0,0,572346625,1280.0 40709304000.0,0,569856166,1290.0 41024880000.0,0,567377753,1300.0 41340456000.0,0,564908008,1310.0 41656032000.0,0,562450828,1320.0 41971608000.0,0,560005832,1330.0 42287184000.0,0,557570018,1340.0 42602760000.0,0,555143734,1350.0 42918336000.0,0,552729893,1360.0 43233912000.0,0,550326162,1370.0 43549488000.0,0,547932312,1380.0 43865064000.0,0,545550017,1390.0 44180640000.0,0,543178924,1400.0 44496216000.0,0,540814950,1410.0 44811792000.0,0,538462704,1420.0 45127368000.0,0,536123339,1430.0 45442944000.0,0,533792776,1440.0 45758520000.0,0,531469163,1450.0 46074096000.0,0,529157093,1460.0 46389672000.0,0,526854383,1470.0 46705248000.0,0,524564196,1480.0 47020824000.0,0,522282564,1490.0 47336400000.0,0,520011985,1500.0 47651976000.0,0,517751635,1510.0 47967552000.0,0,515499791,1520.0 48283128000.0,0,513257373,1530.0 48598704000.0,0,511022885,1540.0 48914280000.0,0,508798440,1550.0 49229856000.0,0,506582663,1560.0 49545432000.0,0,504379227,1570.0 49861008000.0,0,502186693,1580.0 50176584000.0,0,500000869,1590.0 Expanded for More than 2 Nuclides I mentioned that for more than a couple of nuclides you'd want to use a priority queue to track which decays occur next. I reorganized the code around functions, but that allowed greater flexibility in expanding the scope of the problem. Here you go: #!/usr/bin/env python3 from numpy.random import default_rng from math import log import heapq SECONDS_PER_YEAR = 365.25 * 24 * 60 * 60 LOG_2 = log(2) rng = default_rng() def generate_report_qtys(n0): report_qty = [] divisor = 2 while divisor < n0: report_qty.append(n0 // divisor) # append next half-life qty to array divisor *= 2 return report_qty po_n0 = 10_000_000 ra_n0 = 10_000_000 mu_n0 = 10_000_000 # mean is half-life / LOG_2 properties = dict( po_214 = dict( mean = 0.0001643 / LOG_2, qty = po_n0, report_qtys = generate_report_qtys(po_n0) ), ra_226 = dict( mean = 1590 * SECONDS_PER_YEAR / LOG_2, qty = ra_n0, report_qtys = generate_report_qtys(ra_n0) ), made_up = dict( mean = 75 * SECONDS_PER_YEAR / LOG_2, qty = mu_n0, report_qtys = generate_report_qtys(mu_n0) ) ) nuclide_names = [name for name in properties.keys()] def population_mean(nuclide): return properties[nuclide]['mean'] / properties[nuclide]['qty'] def report(): # isolate as single point of maintenance even though it's a one-liner nuc_qtys = [str(properties[nuclide]['qty']) for nuclide in nuclide_names] print(f"{time},{time / SECONDS_PER_YEAR}," + ','.join(nuc_qtys)) def decay_event(nuclide): properties[nuclide]['qty'] -= 1 current_qty = properties[nuclide]['qty'] if current_qty > 0: heapq.heappush(event_q, (time + rng.exponential(population_mean(nuclide)), nuclide)) rep_qty = properties[nuclide]['report_qtys'] if len(rep_qty) > 0 and current_qty == rep_qty[0]: rep_qty.pop(0) # remove this occurrence from the list report() def report_event(): heapq.heappush(event_q, (time + 10 * SECONDS_PER_YEAR, 'report_event')) report() event_q = [(rng.exponential(population_mean(nuclide)), nuclide) for nuclide in nuclide_names] event_q.append((0.0, "report_event")) heapq.heapify(event_q) time = 0.0 # simulated time print("time(seconds),time(years)," + ','.join(nuclide_names)) # column labels while time < 1600 * SECONDS_PER_YEAR: time, event_id = heapq.heappop(event_q) if event_id == 'report_event': report_event() else: decay_event(event_id) To add more nuclides, add more entries to the properties dictionary, following the template of the current entries.
Power BI - Date calculations for a non standard month
Power BI Desktop Version: 2.73.5586.984 64-bit (September 2019) I am creating a calculated column to determine if a ticket has been completed in a "Current" or "Backlog" state. Our reporting period month goes from the 26th of the month to the 25th. If a ticket was completed in the reporting period m/26 - m/25 it would be considered "Current." If the ticket was completed outside of that time frame then it would be "Backlog." Also, if the current ticket has not been completed but still has the possibility of being completed in the same reporting period then that would be listed as "Current", but if it goes on to the next reporting month then it would be "Backlog." Example: Created 1/1/2021 & Completed 1/10/2021 = Current Created 1/1/2021 & Completed 3/18/2021 = Backlog Created 1/25/2021 & Completed 1/26/2021 = Backlog Created 4/20/2021 & Not Completed & Today [4/30/2021] = Backlog Created 4/29/2021 & Not Completed & Today [4/30/2021] = Current I have written the following DAX to handle this but I seem to run into issues after the end/at the start of the reporting period, where the calculations don't work properly and everything lists as either current or backlog. I also have a helper column in my Date Table that determines what the current reporting period is based on the current day, but I am not using it in this formula, but can if it would make it more efficient. What is a better/proper way to do this? Current/Backlog Caluclated Column: Current_Backlog = VAR CreatedDay = Day(IR_SR[Created_Date]) VAR CompletedDay = Day(IR_SR[Completed_Date]) VAR CreatedMonth = Month(IR_SR[Created_Date]) VAR CompletedMonth = Month(IR_SR[Completed_Date]) VAR CreatedMonthAdd = Month(IR_SR[Created_Date])+1 VAR CompletedMonthAdd = Month(IR_SR[Completed_Date])+1 VAR CurrentMonth = Month(TODAY()) VAR CurrentMonthAdd = Month(TODAY())+1 VAR CurrentDay = Day(TODAY()) RETURN //If the date the ticket was completed is before the 26th and the created and completed month match, mark as current IF(CompletedDay < 26 && CreatedMonth = CompletedMonth, "Current", //If the completed date is after or equal to the 26th see if the created month plus one and completed month plus one match, mark as current IF(CreatedDay >= 26 && CompletedDay >= 26 && CreatedMonthAdd = CompletedMonthAdd, "Current", //If the completed date is after or equal to the 26th and the created date is after or equal to the 26th see if the created and completed month plus one match, mark as current IF(CreatedDay >= 26 && CreatedMonthAdd = CompletedMonth, "Current", //If the ticket is not completed and the created date is less then the 26th and the created month and current month match, mark as current IF(IR_SR[Open/Closed] = "Open" && CurrentDay < 26 && CreatedDay < 26 && CreatedMonth = CurrentMonth, "Current", //If the ticket is not completed and the created date is greater then the 26th and the created month and current month match plus one, mark as current IF(IR_SR[Open/Closed] = "Open" && CurrentDay >= 26 && CurrentDay < 1 && CreatedDay >= 26 && CreatedMonthAdd = CurrentMonthAdd, "Current", IF(IR_SR[Open/Closed] = "Open" && CurrentDay < 26 && CurrentDay >= 1 && CreatedDay >= 26 && CreatedMonthAdd = CurrentMonth, "Current", "Backlog")))))) Current Reporting Month: = Table.AddColumn(#"Inserted Day Name", "Reporting_Period", each if Date.Day([Date]) >= 26 then Date.StartOfMonth(Date.AddMonths([Date], 1)) else Date.StartOfMonth([Date]))
an advice in this case. Compare both DAX formula in the performance analyizer inside Power BI and check how much time spent the calculation. I guess all your data are imported, in this case data are cached, so first problem about performance is solved. Anyway, paste second part of your DAX code and I'll check it. Thanks
QlikSense - Set Analysis - Handling complexities - Arithmetic, Fields, Variables, Variables within variables, Greater than etc
I am somewhat new to QlikSense, but am getting a hang of it. Set Analysis is probably my weak spot and no matter how much I read, I tend to forget everything within hours. Plus, the guides don't do a great job explaining how to handle more complex/'tricky' situations (aka Level II or III complexity) than what they deem complex (aka Level 1 complexity) . I went through this, this and this, still no dice. The only thing left for me to do is to bang my head to the wall and see if something shakes up. The actual file is pretty big and proprietary, so can't post it here... so I would appreciate if you can give me an idea and point me in the right direction. GOAL: I have an expression that works, but I need it in the form of set analysis. Simple, right? BACKGROUND: //IN LOAD SCRIPT - set some default values SET dMinSOS = 20000; SET dMaxSUSPD = 225; SET dSUR = 1; SET dSOR = 0.3; //IN LOAD SCRIPT - generate some custom inputs so user can select a value FOR i = 1 to 20 LET counter = i*5000; LOAD * INLINE [ Min. SOS $(counter) ]; NEXT i FOR i = 0 to 9 LET counter = i/10; LOAD * INLINE [ SOR $(counter) ]; NEXT i FOR i = 1 to 30 LET counter = i/10; LOAD * INLINE [ SUR $(counter) ]; NEXT i FOR i = 1 to 15 LET counter = i*25; LOAD * INLINE [ Max. SUSPD $(counter) ]; NEXT i //IN LOAD SCRIPT - if user selects a value from above, then get the max because they can select multiple; otherwise use default values SET vMinSOS = "IF(ISNULL([Min. SOS]), $(dMinSOS), MAX([Min. SOS]))"; SET vMaxSUSPD = "IF(ISNULL([Max. SUSPD]), $(dMaxSUSPD), MAX([Max. SUSPD]))"; SET vSUR = "IF(ISNULL([SUR]), $(dSUR), MAX([SUR]))"; SET vSOR = "IF(ISNULL([SOR]), $(dSOR), MAX([SOR]))"; //EXPRESSION - works! - [Size], [Heads], [SPD] are direct fields in a table, the return value of 1 or 0 is strictly for reference =IF( [Size] >= $(vMinSOS) AND [Size] - ((([Heads] * IF([SPD] >= $(vMaxSUSPD), $(vMaxSUSPD), [SPD])) / $(vSUR)) + ([Size] * $(vSOR))) >= 0, 1, 0) //SET ANALYSIS - this needs fixing - i.e. replicate 2nd condition in expression above - Show just the results where both the conditions above are true =SUM({< [Size]={">=$(=$(vMinSOS))"}, [Size]={">= #### What goes here? #### "}, >}[Size]) Open to recommendations on better ways of solving this.
=SUM({ "=[Size] >= $(vMinSOS) AND [Size] - ((([Heads] * IF([SPD] >= $(vMaxSUSPD), $(vMaxSUSPD), [SPD])) / $(vSUR)) + ([Size] * $(vSOR))) >= 0" }>} [Size] )
Matlab Code for weekdays and weekends [duplicate]
This question already has an answer here: Weekend extraction in Matlab (1 answer) Closed 6 years ago. I were able to successfully made a schedule in which the output is 1 if time is between 7 AM-5PM and otherwise 0, time is based on my computer. However the day Monday-Sunday is based on my computer as well.. I cant find the solution to put an output 1 on Monday-Saturday and output 0 on Sunday. The code I have is below function y = IsBetween5AMand7PM coder.extrinsic('clock'); time = zeros(1,6); time = clock; current = 3600*time(4) + 60*time(5) + time(6); %seconds passed from the beginning of day until now morning = 3600*7; %seconds passed from the beginning of day until 7AM evening = 3600*17; %seconds passed from the beginning of day until 5PM y = current > morning && current < evening; end Now the time here is correct already what I need is for the day (Monday-Sunday) to have my needed output. Also this matlab code is inside a matlab function on Simulink block.
If you use weekday like this, you can generate a 0/1 value as you specified for today's date: if (weekday(now) > 1) day_of_week_flag = 1; else day_of_week_flag = 0; or if you like, this one-liner does the same thing, but may not be as easy to read if you're not familiar with the syntax: day_of_week_flag = ( weekday(now) > 1); You can also use date-strings like this to convert other dates: day_of_week_flag = ( weekday('01-Mar-2016') > 1 ) Finally, if you have a numeric array of date/time values, like [2016 3 3 12 0 0], you first need to convert to a serial date using datenum, then use weekday: time = clock; day_of_week_flag = ( weekday(datenum(time)) > 1); An alternate way to check without using weekday is the following: time = clock; day_of_week = datestr(time, 8); if (day_of_week == 'Sun') day_of_week_flag = 0; else day_of_week_flag = 1;
Working with Dates in Google Apps Script
What I am trying to do here is this - I want to give index to only the workdays in each week. So, if in a week, Monday and Wednesday are holidays, then Tuesday should get 1, Thursday should get 2, Friday should get the index 3. Otherwise, in a normal week without any holidays, Monday should get 1, Tuesday 2, Wednesday 3, and so on ... Here is the code I have written (I haven't coded in years now, so please pardon the crude approach) Sheet 'Holidays' contains a list of holidays in the column B starting from row 2 Variable date is the date for which I want to find out the index for Variable dayOfTheWeek is the number of day of 'date' counted from last Sunday, so if date is a Monday, dayOfTheWeek is 1; if date is Tuesday, dayOfTheWeek is 2, and so on ... function indexOfWorkdayOfTheWeek (date, dayOfTheWeek, lastSundayDate) { var activeSheet = SpreadsheetApp.getActiveSpreadsheet(); var activeCell = activeSheet.getActiveRange(); var activeRow = activeCell.getRowIndex(); var activeColumn = activeCell.getColumn(); var count = 1; for (var j = 1; j < dayOfTheWeek; j++) { var date2 = lastSundayDate.valueOf() + j*86400; Logger.log('Date ' + j + ' is:' + date2); Logger.log('Last Sunday is:' + lastSundayDate); if (holidayOrNot(date2) == true) { } else { count = count + 1; } } return count; } function holidayOrNot(date2) { var holidaysSheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Holidays'); var listOfHolidays = holidaysSheet.getSheetValues(2, 2, 95, 1); var isDateMatch = false; for (var k = 0; k < 90; k++) { if (date2 == listOfHolidays[k].valueOf()) { isDateMatch = true; break; } else { continue; } } return isDateMatch; } I think the problem is two-fold here: The date2 calculation isn't working for some reason (var date2 = lastSundayDate.valueOf() + j*86400;) The function holidayOrNot is returning false, no matter what, even if it encounters a holiday ... the condition date2 == listOfHolidays[k] isn't working for some reason... Help would be appreciated!
maybe this method below could help you in your calculations, it returns an integer corresponding to the day of the year so if you apply this to your holidays days and compare to the days of interest it could be a good way to find matches. here it is, just add these lines outside of any function in your script (so you can use it anywhere) then use it like this : var d = new Date().getDOY(); Logger.log(d) Here the method : Date.prototype.getDOY = function() { var onejan = new Date(this.getFullYear(),0,1); return Math.ceil((this - onejan) / 86400000); }
Assuming that lastSundayDate is being passed around correctly, I see a glaring problem: lastSundayDate.valueOf(). valueOf() on Date objects returns the primitive value... it looks like you're going for adding a day to the date (86400 seconds * j)? I can't tell what the logic is supposed to be here. But the valueOf() date2 is definitely giving you an integer something like: 1384628769399 (see here). What you really want to accomplish is something like Date.getDay(), or something similar so that you can add hours, days, etc. to the original Date. This is likely the source of all your problems. What you can do is read the Mozilla Developer Network documentation on Date objects to see all of the functions on Dates and their uses. You can greatly simplify what you're trying to do by using these functions, instead of doing abstract operations like j * 86400. It should also be noted that you can do simple operations such as the following, to add 4 hours to the current Date (time): var myDate = new Date(); Logger.log(myDate); // ~ console.write var laterDate = new Date(myDate.setHours(myDate.getHours() + 4)); Logger.log(laterDate); // ~ console.write which gives the following: [13-11-16 14:13:38:947 EST] Sat Nov 16 14:13:38 GMT-05:00 2013 [13-11-16 14:13:38:954 EST] Sat Nov 16 18:13:38 GMT-05:00 2013 Working with dates can be tricky - but it's always best to use the simplest methods that are available, which are built into the Date objects themselves. There are also numerous other libraries that provide extended functionality for Dates such as Date js. If you're still running into your problem after attempting to try using methods I displayed above, please run your script and post both the Execution Transcript and the content of the Logger so that I can help you narrow down the issue :)