May 09

On Monday, 9 May 2022 at 03:25:26 UTC, Salih Dincer wrote:

>

Bu da bilinçli değinmedim sorun. Malum türlerin sınırı olduğu için ve Inclusive Range hepsini kapsamaya çalıştığından patlıyor.

Özetle, bu kadarı kadı kızında da olur diyorum ve bu iki durum ile yaşayabilirim. :)

Düzeltiyorum: Yaşayamayız...

Çünkü sonsuz döngü kabul edilemez! İşe gelmek için yolda yürüyorken biraz düşündüm ve az önce mola arasında uyguladım. Aslında çözüm çok basitmiş. Sadece 2. bir bool Empty ve önceki değeri sorgulama mekanizması, kontrolü bir üst seviyeye çıkarıyor:

struct InclusiveRange(T) {
  T front, last, step, term;
  bool Empty;

//...

  bool empty()
  {
    if(Empty) {
      Empty = false;
      return true;
    } else return front > last;
  }

  void popFront()
  {
    const prev = front;
    front += step;
    if(front < prev) Empty = true;
  }
}

unittest
{
  assert(inclusiveRange!byte(0, 127).last == byte.max);
  assert(inclusiveRange!ubyte(0, 255).last == ubyte.max);
  assert(inclusiveRange!int(0, 2147483647).last == int.max);
  assert(inclusiveRange!uint(0, 4294967295).last == uint.max);
}

Pahalı bir çözüm mü?

May 09

On Monday, 9 May 2022 at 07:29:52 UTC, Salih Dincer wrote:

>

Pahalı bir çözüm mü?

Çözümü kanıtlamak için acele etmişim! Bir diziye çevirip aralığı işletmediğim için düzeltmem gerekiyor...

Sanırım aşağıdakiler, temel türler için istediğim (son 2 elemanın dizisini üreten) test oldu. Bundan sonra temel türlere ve char/string gibi izin vermeyen sözleşmeli programlama kısmını yapmak gerekiyor.

unittest
{
  assert(inclusiveRange!byte(byte.max-1, byte.max).array.length == 2);
  // [126, 127]
  assert(inclusiveRange!ubyte(ubyte.max-1, ubyte.max).array.length == 2);
  // [254, 255]
  assert(inclusiveRange!short(short.max-1, short.max).array.length == 2);
  // [32766, 32767]
  assert(inclusiveRange!ushort(ushort.max-1, ushort.max).array.length == 2);
  // [65534, 65535]
  assert(inclusiveRange!int(int.max-1, int.max).array.length == 2);
  // [2147483646, 2147483647]
  assert(inclusiveRange!uint(uint.max-1, uint.max).array.length == 2);
  // [4294967294, 4294967295]
  assert(inclusiveRange!long(long.max-1, long.max).array.length == 2);
  // [9223372036854775806, 9223372036854775807]
  assert(inclusiveRange!ulong(ulong.max-1, ulong.max).array.length == 2);
  // [18446744073709551614, 18446744073709551615]
}

import std.stdio;
import std.range;

void main()
{
  iota!byte(byte.max-1, byte.max).array.writeln;
  iota!ubyte(ubyte.max-1, ubyte.max).array.writeln;
  iota!short(short.max-1, short.max).array.writeln;
  iota!ushort(ushort.max-1, ushort.max).array.writeln;
  iota!int(int.max-1, int.max).array.writeln;
  iota!uint(uint.max-1, uint.max).array.writeln;
  iota!long(long.max-1, long.max).array.writeln;
  iota!ulong(ulong.max-1, ulong.max).array.writeln;
}

iota() çıktısı ve zayıf kaldı durumu ise gözler önünde:

>

[126]
[254]
[32766]
[65534]
[2147483646]
[4294967294]
[9223372036854775806]
[18446744073709551614]

Yani sınırları aralık olarak veremiyor. Özetle artık inclusiveRange(), eski klasik çözüme göre üstün konumda!

Başarılar...

Next ›   Last »
1 2