Biraz da matematik.....

[golgepapaz]

Elimde;

(size + p) mod v =0 gibi bir denklem var;

size ve v nin ne oldugunu biliyorum . yukaridaki esitligi saglayan en kucuk p degerini bulmam gerekiyor;

Duz mantikla soyle bir cozum buldum.(degerlerin hepsi int)

int p= v-(size %v);
Cok birseymis gibi durmuyor ama, yukaridaki kod oldukca performans kritik,acaba burdan daha fazla su cikartabilirmiyim diye merak ediyorum.Belki benim goremedigim bir sey vardir...

Not: Bu arada problemi, ogelerin bellekteki dizilimi ve hizasi ile analojik(!?) olarak dusunebilirisiniz....

[Flagrant]

matematiksel olarak direk (-size % v ) dogru cevabi verir.

[lektroon]

değişkenler, signed mi unsigned mi?

ayrica ben (-size % v) nasil çözüm oluyor anlayamadım. Misal,
(8+p)%3 = 0
durumunu düşünelim.
p = (-8%3) = -2
oluyor. Oysa ki bence p = 1 olması gerek.

Negatif tarafa gerçersek, en küçük sayı signed int' in en alt olası değerine yaklaşık bir değer olacaktır.

[lektroon]

(size+p)%v = 0 => (size%p+p%v)%v =0
Bu durumda:

size%v+p%v= k*v (k=1,2,3,...)

p'nin en küçük değerini arıyorsak, k = 1 olmalı. Bu durumda:
size%v+p%v=v dir.

Ayrıca p<v dir. Bu durumda, p%v = p dir. O zaman,
size%v+p = v
=> p = v-(size%v) dir.

Seninkinden daha kısa bir yol yok gibi.

[cappytoi]

-2 de olur 6 'nın 3 'e bölümünden kalan 0 değil mi? 1 > -2 değil mi?

[lektroon]

cappytoi,
(8+p)%3 = 0 örneğine dönelim. p = -2 bu koşulu sağlıyor. Doğru. 1 > -2 bu da doğru. Ancak, p = -5 de bu koşulu sağlıyor ve -5 < -2. Ayrıca -8 de bu koşulu sağlıyor. -8 < -2
Böyle yaparsan, int'in alabileceği değer aralığında negatif tarafın sonunda bir yerlere kadar gidersin. Soruda p'nin en küçük değeri soruluyordu.

Benim açıklamama dönersek,

size%v+p%v= k*v denkleminde k>=2 de olamıyor. Çünkü, p'nin alabileceği en büyük değer (v-1) olur (p'nin bu koşulu sağlayan en küçük değerini aradığımız için.). size%v ifadesinin en büyük değeri de (v-1) olacaktır. Bu durumda size%v+p%v ifadesinin en büyük değeri 2v-2 olur. Yani k değişkeni 1'den büyük olamaz. Bu durumda,

size%v+p%v=v olur. p%v = p olmak zorunda. p degiskeni v'den büyük olursa bu değer bizim aradığımız şekilde p'nin en küçük değeri olmayacaktır. Çünkü modülo operatörü p%v işlemini p nin her değeri için
0<=(p%v)<=(v-1) aralığına limitleyecektir. Dolayısıyla p'nin en küçük değeri için p < v seçmeliyiz. Bu da p%v = p sonucuna götürecektir. Denklemi yeniden düzenlersek,

size%v+p = v buluruz

Buradan da doğru cevap olarak golgepapaz'in dedigi gibi :

p = v-(size%v) sonucuna ulaşırız.

[Flagrant]

matematikte -8 % 3 genelde 1 diye yazilir ve hesap makineleri de boyle hesaplar. Ama dediginiz gibi compiler -8 % 3 u -2 olarak veriyormus. Bu durumda da geriye sadece sizin dediginiz yontem kaliyor. 8%3 u su sekilde de hesaplayabilirsin 8 - 8/3*3. Ama 8%3 isleminden daha hizli hesaplayip hesaplayamayacagindan emin degilim. Kolay gelsin.

[myavuzselim]

p = v-(size%v) isleminde (size % v) 0 ise sonuc v olur, onu da test etmelisin.

[furkans]

p=(v-(size%v)%v)...myavuzselim doğru söylüyor...

[Revne]

Bu sorunun tek bir cevabı yok

(size + p) % V=0 ise
(size % V) + p%V=0 olur

p%v=-(size%v) olacaktır...

burada p=AxV + B , B< V olmak sartıyla... oldugundan dolayı A nin alacagı degere gore p degeri degişecektir.

eger A=0 dersek
P=B olacaktır... B=-(size %v) olur...


Neyse kolay gelsin...

[lektroon]

revne,
(size + p) % V = 0 ise
(size % V) + (p % V) = 0 olmak zorunda degil. Yanlis dusunuyorsun.
size = 8, v =4, p = 3 olsun.
(8 + 4) % 3 = 0 olur. Ancak,
(8 % 3) + (4 % 3) != 0

((size % v) + (p % v)) % v = 0 olur.

myavuzselim,
dedigin dogru. p'yi 0 ile v-1 aralığına limitlemek gerek. O yüzden en doğrusu:

p = (v - (size % v)) % v

olmalı bence.

[t-hex]

(size + p) mod v = 0 işlemi size + p = kv demekle aynıdır. (k pozitif bir tam sayı veya 0 olabilir).

p'yi de p = kv - size olarak çekebiliriz. @lektroon'un örneğinden yola çıkarak (size=8, v=3)

k=0 için p = -8
k=1 için p=-5
k=2 için p=-2
k=3 için p=1 olacaktır.
p'nin en küçük pozitif tamsayı değerini bulabilmek için k*v > size >(k-1)*v koşulunun sağlanması gerekir.

p = (v - (size % v)) % v işlemindeki gibi 2 defa mod almak yerine kısaca

p= (size -v ) %v işlemi ile mod almayı teke düşürüp, 0'a en yakın modüloyu bulup, eğer sonuç 0'dan küçükse v ekleyerek elde edebiliriz diye düşünüyorum



int p = (v - size) % v ;
p = Math.Max(p, p + v);

[t-hex]

int p = (v - size) % v ;
if (p<0) p+=v;


olsa daha iyi olur. max, p < 0 için işe yarıyor.

[golgepapaz]

ilgi icin tesekkurler arkadaslar;

myavuzselim,furkans,lektroon: evet yazdigim kodda da cift modulo islemi var. yani size mod v =0 zaten idare ediliyor. aslinda gercekleme soyle;

pad = (offset+size) % octetBoundary;
pad =(octetBoundary - pad) % octetBoundary;


sanirim bunu daha fazla kismak pek mumkun degil ....

t-hex: ikinci sikki bende dusunmustum ama ,orada lazy evaluation dan yararlanabilme imkani olmasina ragmen, if kontrolunun ve toplama isleminin ,ekstra modulodan daha hizli olup olmadigindan emin olamadim (ayrica if ile ilgili estetik kaygilarim var ;)). Gerci profile edip karsilastirmak lazim ama ugrasmak istemiyorum..