private SeasonalityDefinition(DoubleArray seasonalityMonthOnMonth, ShiftType adjustmentType) { JodaBeanUtils.notNull(seasonalityMonthOnMonth, "seasonalityMonthOnMonth"); JodaBeanUtils.notNull(adjustmentType, "adjustmentType"); this.seasonalityMonthOnMonth = seasonalityMonthOnMonth; this.adjustmentType = adjustmentType; }
public OpCode32AluRsImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rm = (opCode >> 0) & 0xf; Immediate = (opCode >> 7) & 0x1f; ShiftType = (ShiftType)((opCode >> 5) & 3); }
/// <summary> /// Prevents a default instance of the <see cref="Operand"/> class from being created. /// </summary> /// <param name="shiftType">Type of the shift.</param> private Operand(ShiftType shiftType) : this() { ShiftType = shiftType; IsShift = true; IsResolved = true; }
private ShiftType GetSelectedShiftType() { int rowindex = 0; int columnindex = 0; if (dgvSchedule.CurrentCell.RowIndex > -1 && dgvSchedule.CurrentCell.ColumnIndex > -1) { rowindex = dgvSchedule.CurrentCell.RowIndex; columnindex = dgvSchedule.CurrentCell.ColumnIndex; if (rowindex == 1) { selectedshift = ShiftType.Morning; } if (rowindex == 2) { selectedshift = ShiftType.Afternoon; } if (rowindex == 3) { selectedshift = ShiftType.Evening; } } else { MessageBox.Show("Please select a cell first"); } return(selectedshift); }
private void AddOrRemoveShift(ShiftType shiftType, bool isToggled) { var workShift = _workShiftsRepository.Get(SelectedDate, shiftType); if (isToggled) { if (workShift == null) { var newWorkShift = new WorkShift { Date = SelectedDate, ShiftType = shiftType }; var inlineCalendarEvent = WorkShiftConverter.ToCalendarInlineEvent(newWorkShift); _workShiftsRepository.Insert(newWorkShift); WorkShifts.Add(inlineCalendarEvent); _workshiftCalendar.Add(newWorkShift, inlineCalendarEvent); } } else { if (workShift != null) { var foundCalendarItem = _workshiftCalendar[workShift]; _workShiftsRepository.Delete(workShift); WorkShifts.Remove(foundCalendarItem); _workshiftCalendar.Remove(workShift); } } }
public OpCode32AluRsReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rm = (opCode >> 0) & 0xf; Rs = (opCode >> 8) & 0xf; ShiftType = (ShiftType)((opCode >> 5) & 3); }
public OpCodeT32AluRsImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rm = (opCode >> 0) & 0xf; Immediate = ((opCode >> 6) & 3) | ((opCode >> 10) & 0x1c); ShiftType = (ShiftType)((opCode >> 4) & 3); }
public void Shift(bool reverse, ShiftType shiftType = ShiftType.OneTube) { Logger.Debug($"[{nameof(ConveyorUnit)}] - Start shift."); List <ICommand> commands = new List <ICommand>(); commands.Add(new SetSpeedCommand(Options.ConveyorStepper, (uint)Options.ConveyorSpeed)); int steps = Options.ConveyorStepsPerSingleTube; if (shiftType == ShiftType.HalfTube) { steps /= 2; } if (reverse) { steps *= -1; } steppers = new Dictionary <int, int>() { { Options.ConveyorStepper, steps } }; commands.Add(new MoveCncCommand(steppers)); executor.WaitExecution(commands); Logger.Debug($"[{nameof(ConveyorUnit)}] - Shift finished."); }
public Shift(EmployeeDepartment employeeDepartment, DateTime datetime, ShiftType shiftType, int shiftnum) // this is for reading shifts from the DB { EmployeeDepartment = employeeDepartment; this.DateTime = datetime; ShiftType = shiftType; ShiftNumber = shiftnum; }
public OpCodeT16ShiftImm(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rd = (opCode >> 0) & 0x7; Rm = (opCode >> 3) & 0x7; Immediate = (opCode >> 6) & 0x1F; ShiftType = (ShiftType)((opCode >> 11) & 3); }
/* #impl-aarch64.ShiftReg.3 */ public static Bits ShiftReg(int N, int reg, ShiftType type, int amount) { Bits result = X(N, reg); switch (type) { default: case ShiftType.ShiftType_LSL: result = LSL(result, amount); break; case ShiftType.ShiftType_LSR: result = LSR(result, amount); break; case ShiftType.ShiftType_ASR: result = ASR(result, amount); break; case ShiftType.ShiftType_ROR: result = ROR(result, amount); break; } return(result); }
/// <summary> /// Prevents a default instance of the <see cref="Operand"/> class from being created. /// </summary> /// <param name="shiftType">Type of the shift.</param> private Operand(ShiftType shiftType) : this() { ShiftType = shiftType; IsShift = true; IsResolved = true; }
public OpCode32AluRsImm(Inst inst, long position, int opCode) : base(inst, position, opCode) { Rm = (opCode >> 0) & 0xf; Imm = (opCode >> 7) & 0x1f; ShiftType = (ShiftType)((opCode >> 5) & 3); }
private CurveParallelShifts(ShiftType shiftType, DoubleArray shiftAmounts) { JodaBeanUtils.notNull(shiftType, "shiftType"); JodaBeanUtils.notNull(shiftAmounts, "shiftAmounts"); this.shiftType = shiftType; this.shiftAmounts = shiftAmounts; }
public async Task <IActionResult> Edit(int id, [Bind("ShiftTypeId,Name,StartOffsetHrs,StartOffsetMins,RoasterSequence,ShiftSequence,ColorString")] ShiftType shiftType) { if (id != shiftType.ShiftTypeId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(shiftType); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ShiftTypeExists(shiftType.ShiftTypeId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(shiftType)); }
public ButtonConfig() { _isEnabled = false; _physicalNumber = 0; _shiftModificator = 0; _type = ButtonType.Button_Normal; }
public ButtonConfig(ButtonType type) { _isEnabled = false; _physicalNumber = 0; _shiftModificator = 0; _type = type; }
//Constructor public Shift(EmployeeDepartment employeeDepartment, Employee employee, DateTime datetime, ShiftType shiftType) // this is for getting day as an input string (one week) { EmployeeDepartment = employeeDepartment; this.DateTime = datetime; ShiftType = shiftType; employees = new List <Employee>(); employees.Add(employee); }
public OpCodeT16ShiftReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rd = (opCode >> 0) & 7; Rm = (opCode >> 0) & 7; Rn = (opCode >> 3) & 7; Rs = (opCode >> 3) & 7; ShiftType = (ShiftType)(((opCode >> 6) & 1) | ((opCode >> 7) & 2)); }
private ParallelShiftedCurve(Curve underlyingCurve, ShiftType shiftType, double shiftAmount) { JodaBeanUtils.notNull(underlyingCurve, "underlyingCurve"); JodaBeanUtils.notNull(shiftType, "shiftType"); JodaBeanUtils.notNull(shiftAmount, "shiftAmount"); this.underlyingCurve = underlyingCurve; this.shiftType = shiftType; this.shiftAmount = shiftAmount; }
public OpCode32Sat(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode) { Rn = (opCode >> 0) & 0xf; Imm5 = (opCode >> 7) & 0x1f; Rd = (opCode >> 12) & 0xf; SatImm = (opCode >> 16) & 0x1f; ShiftType = (ShiftType)((opCode >> 5) & 2); }
/// <summary> /// Creates an instance. </summary> /// <param name="shiftType"> the value of the property, not null </param> /// <param name="shifts"> the value of the property, not null </param> /// <param name="nodeIndices"> the value of the property, not null </param> internal PointShifts(ShiftType shiftType, DoubleMatrix shifts, IDictionary <object, int> nodeIndices) { JodaBeanUtils.notNull(shiftType, "shiftType"); JodaBeanUtils.notNull(shifts, "shifts"); JodaBeanUtils.notNull(nodeIndices, "nodeIndices"); this.shiftType = shiftType; this.shifts = shifts; this.nodeIndices = ImmutableMap.copyOf(nodeIndices); }
private void Shift(OperationDirection direction, ShiftType shiftType) { byte result = ALURightBuffer; bool leftmostBitIsSet = (result & B10000000) != 0; // Shift 1 bit to the left or to the right if (direction == OperationDirection.Left) { result <<= 1; if (shiftType == ShiftType.Logical) { result |= B00000001; } CF = leftmostBitIsSet; } else if (direction == OperationDirection.Right) { bool rightmostBitIsSet = (result & B00000001) != 0; result >>= 1; if (shiftType == ShiftType.Arithmetic && leftmostBitIsSet) { result |= B10000000; } CF = rightmostBitIsSet; } // Send result to the data bus InternalDataBus = result; // Compute flags // HF an NF are always reset // SF, ZF, PF, XF and YF will be updated F &= B00000001; // Flags bit 5 - YF flag - A copy of bit 5 of the result. // Flags bit 3 - XF flag - A copy of bit 3 of the result. F |= (byte)(result & B00101000); // Flags bit 7 - SF flag - Set if the 2-complement value is negative. It's simply a copy of the most signifcant bit of the result. F |= (byte)(result & B10000000); // Flags bit 6 - ZF flag Set if the result is zero. if (result == 0) { F |= B01000000; } // PF : parity of the result PF = numberOfBitsInByteParityTable[result]; if (TraceMicroInstructions) { TraceMicroInstruction(new MicroInstruction(Z80MicroInstructionTypes.BitOperationShift, direction, shiftType)); } }
//------------------------------------------------------------------------- // restricted constructor //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ImmutableConstructor private InflationNodalCurve(NodalCurve curve, com.opengamma.strata.collect.array.DoubleArray seasonality, com.opengamma.strata.market.ShiftType adjustmentType) private InflationNodalCurve(NodalCurve curve, DoubleArray seasonality, ShiftType adjustmentType) { this.underlying = curve; this.seasonality = seasonality; this.xFixing = curve.XValues.get(0); this.yFixing = curve.YValues.get(0); int i = seasonalityIndex(xFixing); ArgChecker.isTrue(adjustmentType.applyShift(yFixing, seasonality.get(i)) - yFixing < 1.0E-10, "Fixing value should be unadjusted"); this.adjustmentType = adjustmentType; }
public static byte GetShiftTypeCode(ShiftType shiftType) { switch (shiftType) { case ShiftType.LogicalLeft: return Bits.b00; case ShiftType.LogicalRight: return Bits.b01; case ShiftType.ArithmeticRight: return Bits.b10; case ShiftType.RotateRight: return Bits.b11; default: throw new NotSupportedException(); } }
public async Task <IActionResult> Create([Bind("ShiftTypeId,Name,StartOffsetHrs,StartOffsetMins,RoasterSequence,ShiftSequence,ColorString")] ShiftType shiftType) { if (ModelState.IsValid) { _context.Add(shiftType); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(shiftType)); }
private void AddShift(List <Shift> shifts, int index, string last, ShiftType type) { if (last != "") { var lastShift = shifts.Last(); lastShift.Interval.End = TimeByIndex(index); } var interval = new TimeInterval(TimeByIndex(index), TimeByIndex(48)); var shift = new Shift(interval, CurrentDate, type); shifts.Add(shift); }
public ButtonConfig(ButtonType type) { _isEnabled = false; _isInverted = false; _isDisabled = false; _physicalNumber = 0; _shiftModificator = ShiftType.NoShift; _buttonDelayNumber = TimerType.No; _buttonToggleNumber = TimerType.No; _type = type; }
private static DateTime AddShiftEntries(Staff s, DateTime t, int working, ShiftType shiftType, IList <ShiftPlanEntry> entries) { for (int d = 0; d < working; d++) { if (IsValidWish(s, t)) { t = AddShiftEntry(entries, t, s, shiftType); } } return(t); }
public static bool isHolidayDate(DateTime punchDate, ShiftType shift) { try { bool isHol; using (var db = new iTimeServiceContext()) { isHol = db.Set <Holiday>() .Where(x => DbFunctions.TruncateTime(x.holdate) == punchDate.Date) .Where(x => x.compid == _compId && x.isactive == true && x.isdeleted == false) .Count() > 0; } if (!isHol) { if (punchDate.DayOfWeek == DayOfWeek.Saturday && shift.issatwkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Sunday && shift.issunwkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Monday && shift.ismonwkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Tuesday && shift.istuewkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Wednesday && shift.iswedwkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Thursday && shift.isthuwkday != true) { isHol = true; } else if (punchDate.DayOfWeek == DayOfWeek.Friday && shift.isfriwkday != true) { isHol = true; } } return(isHol); } catch (Exception ex) { _processedOk = false; _exception = ex; return(false); } }
public async Task <List <EmployeeNightStatsDTO> > Handle(GetAllEmployeeNightStatsQuery request, CancellationToken cancellationToken) { List <EmployeeNightStatsDTO> vm = new List <EmployeeNightStatsDTO>(); // get all the shift participations List <ShiftParticipation> shiftParts = await _context.ShiftParticipations.Where(sp => sp.Shift.ShiftDate >= request.StartDate.Date && sp.Shift.ShiftDate <= request.EndDate.Date) .Include(sp => sp.ShiftParticipationType) .Include(sp => sp.Shift) .ThenInclude(s => s.ShiftType) .ToListAsync(); ShiftType nShiftType = (await _context.ShiftTypes.Where(s => s.Name.ToLower().Contains("night shift")).ToListAsync()).ElementAt(0); List <ShiftParticipationType> shiftPartTypes = await _context.ShiftParticipationTypes.ToListAsync(); List <ApplicationUser> employees = await _userManager.Users .Include(e => e.ShiftGroup) .Include(e => e.ShiftRole) .Include(e => e.Gender) .ToListAsync(); // compute stats for each employee foreach (ApplicationUser emp in employees) { string userRole = ""; IList <string> existingRoles = await _userManager.GetRolesAsync(emp); if (existingRoles.Count > 0) { userRole = existingRoles.ElementAt(0); } if (userRole != SecurityConstants.AdminRoleString) { UserDTO uDTO = _mapper.Map <UserDTO>(emp); uDTO.UserRole = userRole; EmployeeNightStatsDTO stats = new EmployeeNightStatsDTO { Employee = uDTO }; int numEmpShiftsOfThisType = shiftParts.Count(sp => sp.EmployeeId == emp.Id && sp.Shift.ShiftTypeId == nShiftType.Id); stats.NumNightShiftsAllotted = numEmpShiftsOfThisType; List <ShiftParticipation> attendedNightShiftParts = shiftParts.Where(sp => sp.EmployeeId == emp.Id && sp.Shift.ShiftTypeId == nShiftType.Id && !sp.ShiftParticipationType.IsAbsence).ToList(); string nightShiftDates = String.Join(", ", attendedNightShiftParts.Select(p => p.Shift.ShiftDate.Day).OrderBy(x => x).ToArray()); stats.NightShiftDates = nightShiftDates; stats.NumNightShiftsAttended = attendedNightShiftParts.Count; vm.Add(stats); } } return(vm); }
public List <Shift> GetSpecificShifts(Days day, ShiftType ShiftType) { List <Shift> SpesShifts = new List <Shift>(); foreach (Shift s in shifts) { if (s.WeeklyDay == day && s.ShiftType == ShiftType) { SpesShifts.Add(s); } } return(SpesShifts); }
/// <summary> /// Parses a shift instruction /// </summary> /// <param name="op">The ShiftType for this instruction</param> private void ParseShift(ShiftType op) { // Parse left side byte reg; ParseSmallSymbol(SymbolType.Register, out reg); // Create the shift statement based on register AddInstruction(new Shift(op, reg)); }
/// <summary> /// Creates the shifter. /// </summary> /// <param name="shiftType">Type of the shift.</param> /// <returns></returns> public static Operand CreateShifter(ShiftType shiftType) { var operand = new Operand(shiftType); return operand; }
/// <summary> /// Creates a new Shift instruction /// </summary> /// <param name="type">the type of the instruction</param> /// <param name="reg">the register (must be less than 16)</param> public Shift(ShiftType type, byte reg) { this.Type = type; this.Register = reg; }
/// <summary> /// Prevents a default instance of the <see cref="Operand"/> class from being created. /// </summary> /// <param name="shiftType">Type of the shift.</param> private Operand(ShiftType shiftType) : this() { this.ShiftType = shiftType; this.IsShift = true; }
private void Shift(OperationDirection direction, ShiftType shiftType) { byte result = ALURightBuffer; bool leftmostBitIsSet = (result & B10000000) != 0; // Shift 1 bit to the left or to the right if (direction == OperationDirection.Left) { result <<= 1; if (shiftType == ShiftType.Logical) result |= B00000001; CF = leftmostBitIsSet; } else if (direction == OperationDirection.Right) { bool rightmostBitIsSet = (result & B00000001) != 0; result >>= 1; if (shiftType == ShiftType.Arithmetic && leftmostBitIsSet) result |= B10000000; CF = rightmostBitIsSet; } // Send result to the data bus InternalDataBus = result; // Compute flags // HF an NF are always reset // SF, ZF, PF, XF and YF will be updated F &= B00000001; // Flags bit 5 - YF flag - A copy of bit 5 of the result. // Flags bit 3 - XF flag - A copy of bit 3 of the result. F |= (byte)(result & B00101000); // Flags bit 7 - SF flag - Set if the 2-complement value is negative. It's simply a copy of the most signifcant bit of the result. F |= (byte)(result & B10000000); // Flags bit 6 - ZF flag Set if the result is zero. if (result == 0) F |= B01000000; // PF : parity of the result PF = numberOfBitsInByteParityTable[result]; if (TraceMicroInstructions) { TraceMicroInstruction(new MicroInstruction(Z80MicroInstructionTypes.BitOperationShift, direction, shiftType)); } }
public void EmitInstructionWithRegister(ConditionCode conditionCode, byte opcode, bool setCondition, int firstRegister, int destinationRegister, ShiftType secondShiftType, int secondRegister) { Debug.Assert(opcode <= 0xF); Debug.Assert(destinationRegister <= 0xF); Debug.Assert(firstRegister <= 0xF); Debug.Assert(secondRegister <= 0xF); uint value = 0; value |= (uint)(GetConditionCode(conditionCode) << 28); value |= (uint)(0x0 << 25); value |= (uint)(opcode << 21); value |= (uint)(setCondition ? 1 : 0 << 20); value |= (uint)(firstRegister << 16); value |= (uint)(destinationRegister << 12); value |= (uint)(GetShiftTypeCode(secondShiftType) << 4); value |= (uint)secondRegister; Write(value); }
public void EmitSingleDataTransfer(ConditionCode conditionCode, Indexing indexing, OffsetDirection offsetDirection, TransferSize transferSize, WriteBack writeBack, TransferType transferType, int firstRegister, int destinationRegister, ShiftType secondShiftType, int secondRegister) { Debug.Assert(destinationRegister <= 0xF); Debug.Assert(firstRegister <= 0xF); Debug.Assert(secondRegister <= 0xF); uint value = 0; value |= (uint)(GetConditionCode(conditionCode) << 28); value |= (uint)(1 << 26); value |= (uint)(1 << 25); value |= (uint)((indexing == Indexing.Post ? 0 : 1) << 24); value |= (uint)((transferSize == TransferSize.Word ? 0 : 1) << 23); value |= (uint)((offsetDirection == OffsetDirection.Down ? 0 : 1) << 22); value |= (uint)((writeBack == WriteBack.NoWriteBack ? 0 : 1) << 21); value |= (uint)((transferType == TransferType.Store ? 0 : 1) << 20); value |= (uint)(destinationRegister << 12); value |= (uint)(firstRegister << 16); value |= (uint)(GetShiftTypeCode(secondShiftType) << 4); value |= (uint)secondRegister; Write(value); }