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...

May 29

Merhaba,

iota şunu yapıyor ama bizim yapı yarı yolda kalıyor:

  iota(-5, 0).writeln; // [-5, -4, -3, -2, -1]
  ir(-5, 0).writeln; // []

Bunun çözümünü henüz bilmiyorum ama v2.1.0 ile sorunsuz çalışıyor, bildirmek istedim. Çözene kadar da iota'nın yerini alamayacağını düşünüyorum. Tek sorun o kaldı :)

Bunun dışında ilk defa enumerate() ile denedim, çalışıyor:

void main()
{
  enum start = 11, end = 20;
  auto range = start.inclusiveRange(end);

  foreach(index, test; range.enumerate(start))
  {
    writeln(index, ": ", test);
    assert(index == test);
  }
}

Malum, aralıklar dizilerde olduğu gibi bir index değeri sunamıyor. Çalışıp çalışmadığını merak etmiştim.

Bu arada yeni D sürümünden memnun olmayanlar var, bakalım Haziran'da n'olcak :)

Sevgiler, saygılar...

Next ›   Last »
1 2