C#: Decrementando um relógio usando o Modulus Math
Pergunta
Tentando imitar a rolagem de um relógio de 24 horas à mão (com matemática versus uso das classes de tempo). A parte incrementadora foi fácil de descobrir como rolar das 23:00 às 0:00 e de, mas fazer com que ele vá para o outro lado está se tornando realmente confuso. Aqui está o que tenho até agora:
static void IncrementMinute(int min, int incr)
{
int newMin = min + incr,
hourIncrement = newMin / 60;
//increment or decrement the hour
if((double)newMin % 60 < 0 && (double)newMin % 60 > -1)
hourIncrement = -1;
Console.WriteLine("Hour increment is {0}: ", hourIncrement);
}
O problema que estou descobrindo é quando voltar para trás, se o módulo de IS entre os números, ele não diminuirá corretamente. Exemplo: São 12:00 e você subtraia 61 minutos, sabemos que o tempo seria 10:59, pois a hora deve voltar 1 hora para passar das 12:00 às 11:59, depois de volta por ir a partir das 11:00 a 10:59. Infelizmente, a maneira como estou calculando -o: Newmin % 60 neste caso, pega apenas a primeira hora, mas como a segunda reversão é tecnicamente -1,0166 como um restante e, como o MOD retorna apenas um número inteiro, está arredondando. Tenho certeza de que estou perdendo alguma matemática básica aqui, mas alguém poderia me ajudar?
EDIT: Eu escrevi isso de várias maneiras longas e curtas. Alguns estão mais próximos que outros, mas eu sei que isso é mais simples do que parece. Eu sei que esse parece "o que ele estava fazendo", mas você deve poder ver basicamente o que estou tentando fazer. É fácil incrementar um relógio e fazer uma rolagem de 23:59 às 0:00. Voltar para trás provou não ser tão fácil.
Ok, aqui está o minuto incremento com a rolagem. Simples. Mas tente voltar para trás. Não funciona.
static void IncrementMinute(int min, int incr)
{
int newMin = min + incr,
hourIncrement = newMin / 60;
min = newMin % 60;
Console.WriteLine("The new minute is {0} and the hour has incremented by {1}", min, hourIncrement);
}
Solução
Eu iria para algo um pouco mais simples
public class Clock
{
public const int HourPerDay = 24;
public const int MinutesPerHour = 60;
public const int MinutesPerDay = MinutesPerHour * HourPerDay;
private int totalMinutes;
public int Minute
{
get { return this.totalMinutes % MinutesPerHour; }
}
public int Hour
{
get { return this.totalMinutes / MinutesPerHour; }
}
public void AddMinutes(int minutes)
{
this.totalMinutes += minutes;
this.totalMinutes %= MinutesPerDay;
if (this.totalMinutes < 0)
this.totalMinutes += MinutesPerDay;
}
public void AddHours(int hours)
{
this.AddMinutes(hours * MinutesPerHour);
}
public override string ToString()
{
return string.Format("{0:00}:{1:00}", this.Hour, this.Minute);
}
}
Uso de amostra:
new Clock().AddMinutes(-1); // 23:59
new Clock().AddMinutes(-61); // 22:59
new Clock().AddMinutes(-1441); // 23:59
new Clock().AddMinutes(1); // 00:01
new Clock().AddMinutes(61); // 01:01
new Clock().AddMinutes(1441); // 00:01
Outras dicas
Você pode tentar calcular os incrementos de minuto e hora primeiro e depois lidar com casos em que os novos minutos passam por uma hora, algo assim:
int hourIncrement = incr / 60;
int minIncrement = incr % 60;
int newMin = min + minIncrement;
if (newMin < 0)
{
newMin += 60;
hourIncrement--;
}
else if (newMin > 60)
{
newMin -= 60;
hourIncrement++;
}
Editar
Eu gosto da resposta @Ben Voigts, mas queria saber se haveria alguma diferença no desempenho. Eu executei o aplicativo de console abaixo para cronometrar os dois e fiquei um pouco surpreso com os resultados.
- 40 ms para o código acima
- 2876 ms para a resposta de Ben
Isso foi feito em uma versão de lançamento. Alguém mais pode executar isso e confirmar? Estou cometendo erros na maneira como eu os cronometrar?
using System;
using System.Diagnostics;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Stopwatch sw = new Stopwatch();
int max = 100000000;
sw.Start();
for (int i = 0; i < max; i++)
IncrementMinute1(0, -61);
sw.Stop();
Console.WriteLine("IncrementMinute1: {0} ms", sw.ElapsedMilliseconds);
sw.Reset();
sw.Start();
for (int i = 0; i < max; i++)
IncrementMinute2(0, -61);
sw.Stop();
Console.WriteLine("IncrementMinute2: {0} ms", sw.ElapsedMilliseconds);
Console.ReadLine();
}
static void IncrementMinute1(int min, int incr)
{
int hourIncrement = incr / 60;
int minIncrement = incr % 60;
int newMin = min + minIncrement;
if (newMin < 0)
{
newMin += 60;
hourIncrement--;
}
else if (newMin > 60)
{
newMin -= 60;
hourIncrement++;
}
}
static void IncrementMinute2(int min, int incr)
{
min += incr;
int hourIncrement = (int)Math.Floor(min / 60.0);
min -= hourIncrement * 60;
}
}
}
A matemática modular é definida apenas para os números inteiros. Se você estiver tentando misturar aritmética modular com números reais, não terá sucesso. Você precisa descobrir uma abordagem matemática diferente.
Tentar
int newMin = min + incr,
hourIncrement = (int)Math.Floor(newMin / 60.0);
min -= hourIncrement * 60;
O problema essencial era que você quer hourIncrement
Para completar, mas a divisão inteira rodadas em direção a zero. Eles são iguais com números positivos, mas não para negativos ...
Editar (livrar -se da variável extra inútil):
min += incr;
int hourIncrement = (int)Math.Floor(min / 60.0);
min -= hourIncrement * 60;
Edit2 (Evite aritmética de ponto flutuante):
min += incr;
int hourIncrement = min / 60;
min -= hourIncrement * 60;
if (min < 0) { min += 60; --hourIncrement; }
Por que complicar coisas
public System.Timers.Timer timer = new System.Timers.Timer(1000);
public DateTime d;
public void init()
{
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
d = new DateTime(2011, 11, 11, 23, 59, 50);
d=d.AddHours(1);
Console.Writeline(d);
d=d.AddHours(-2);
Console.Writeline(d);
timer.Enabled = true;
}
void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
this.Dispatcher.Invoke(DispatcherPriority.Normal, (Action)(() =>
{
MoveClockHands();
d=d.AddSeconds(1);
Console.WriteLine(d);
}));
}
void MoveClockHands() //12 hours clock
(
s=d.Second * 6;
m=d.Minute * 6;
h=0.5 * ((d.Hour % 12) * 60 + d.Minute)
}