Jump to content
  • 0

Berekenen aantal dozen


Maatwerk

Question

Hoi mensen,

 

Ik heb een probleem met het berekenen van het aantal dozen.

 

Ik heb nl een klant die bepaalde producten verstuurd in diverse oplagen.

Hij verstuurd deze in dozen van verschillende formaten.

 

t.w.

kleine doos van 0 tot 500

middel doos van 500 tot 1250

en een grote doos van 1250 tot 2500

 

Bedoeling is dat wanneer de klant een oplage besteld van bv 3000 dus ie dus neemt...

 

Een groote doos van 2500 vel en een kleine van 500 vel

 

Heeft ie een oplage van bv 2600 ook een groote doos van 2500 vel en de rest in de kleine doos.

 

Dus hij moet dus gebruik maken van de maximale doosinhoud en het restant een de kleinst beschikbare doos...

 

Ik zit nu al uren bezig om dit te berekenen in een formule echter ik zit vast. Heeft iemand een idee?

Link to comment

Recommended Posts

  • 0

Ik heb een probleem met het berekenen van het aantal dozen.

 

Kijk eens of bijgesloten attachment aan je wensen voldoet.

Scripts zijn m.i. overbodig en recursieve functie niet bruikbaar omdat de laatste stap anders is. Dozen met een meer regelmatige inhoud (500, 1000, 2000) zou makkelijker zijn geweest, maar ja die dozenfabrikant... :-)

 

Groet,

René

Dozen demo.fp7

Link to comment
  • 0

Inderdaad een leuke oefening. Ik zat in dezelfde richting te zoeken.

Wiskundig gezien zit je juist maar bij je laatste voorbeeld is het wellicht economischer om:

 

12345

Groot: 4

Middel: 2

Klein: 0

 

hebben, ipv hetgeen de formule voorstelt:

12345

Groot: 4

Middel: 1

Klein: 3

.

Bij het gebruik van 2 middelgrote dozen heb, je ruimte voor 155 exemplaren over in de 2e doos.

 

Bij het gebruik van 1 middelgrote doos en 3 kleine dozen heb je plaats voor 405 exemplaren voor de derde doos. De derde doos bevat slechts 95 exemplaren.

 

Ik ben nog niet uit hoe je dit kan opvangen in een formule.

 

Koen

Link to comment
  • 0

Ik kwam tot volgende formule:

 

Let
(
[
oplage =  12345
;
floordoos1 = Floor(Oplage / 2500)
;
ceilingdoos1 = Ceiling(Oplage / 2500)
;
restdoos1 = (ceilingdoos1 * 2500) - Oplage
;
floordoos2 = Floor((Oplage -(floordoos1 * 2500) ) / 1250)
;
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * 2500) ) / 1250)
;
restdoos2 = (floordoos1 * 2500) + (ceilingdoos2 * 1250) - Oplage
;
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * 2500)  -(floordoos2 * 1250) ) / 500)
;
restdoos3 = (floordoos1 * 2500) + (floordoos2 * 1250) + (ceilingdoos3 * 500) - Oplage
;
minrest =  Min(restdoos1; restdoos2; restdoos3)
;
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1)
;
doos2 = Case (restdoos1 = minrest ; floordoos2 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2)
;
doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3)
;
result = "Groot: " & doos1 & "¶" & "Middel: " & doos2 & "¶" & "Klein: " & doos3 & "¶"
]
;
result

)

 

Ik probeer hier een configuratie te berekenen met zo min mogelijk plaats in de dozen. (Restwaarde)

 

Koen

Link to comment
  • 0

De recursie functie werkt uitstekend. Echter ik moet ook nog het zelfde doen met envelopen.

 

Hier heb ik 4 dozen n.l. :

 

125 stuks

250 stuks

500 stuks

1000 stuks

 

Wat moet ik in deze formule aanpassen op het aantal dozen zo economisch mogelijk te vullen?

Link to comment
  • 0

Het is geen recursieve functie. We roepen onszelf niet telkens herop. Voor de enveloppes dupliceer je de functie en voeg je nog een extra doos toe.

 

Let
(
[
oplage =  12345
;
maxdoos1 = 1000
;
maxdoos2 = 500
;
maxdoos3 = 250
;
maxdoos4= 125
;
floordoos1 = Floor(Oplage / maxdoos1)
;
ceilingdoos1 = Ceiling(Oplage /maxdoos1)
;
restdoos1 = (ceilingdoos1 * maxdoos1) - Oplage
;
floordoos2 = Floor((Oplage -(floordoos1 * maxdoos1) ) / maxdoos2)
;
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * maxdoos1) ) / maxdoos2)
;
restdoos2 = (floordoos1 * maxdoos1) + (ceilingdoos2 * maxdoos2) - Oplage
;
floordoos3 =  Floor((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) ) / maxdoos3)
;
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) ) / maxdoos3)
;
restdoos3 = (floordoos1 * maxdoos1) + (floordoos2 * maxdoos2) + (ceilingdoos3 * maxdoos3) - Oplage
;
ceilingdoos4 =  Ceiling((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) -(floordoos3 * maxdoos3) ) / maxdoos4)
;
restdoos4 = (floordoos1 * maxdoos1) + (floordoos2 * maxdoos2) + (floordoos3 * maxdoos3) + (ceilingdoos4 * maxdoos4)- Oplage
;
minrest =  Min(restdoos1; restdoos2; restdoos3; restdoos4)
;
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1)
;
doos2 = Case (restdoos1 = minrest ; floordoos2 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2)
;
doos3 = Case (restdoos1 = minrest ; floordoos3 ;restdoos2 = minrest ; floordoos3  ;restdoos3 = minrest; ceilingdoos3   ; floordoos3)
;
doos4 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0  ;restdoos3 = minrest; 0   ; ceilingdoos4)
;
result = "Doos " & maxdoos1 & ": " & doos1 & "¶" &  "Doos " & maxdoos2 & ": " &doos2 & "¶" &  "Doos " & maxdoos3 & ": "  & doos3 & "¶" &  "Doos " & maxdoos4 & ": "  & doos4 & "¶"
]
;
result

)

 

Wellicht kan het een en andere generieker...

 

Koen

Link to comment
  • 0

Volgens mij moet het ook nog simpeler kunnen:

 

grote doos = Int ( oplage / 2500 )

middel doos = Ceiling ( (oplage - grote doos * 2500 - 500) / 1250 )

kleine doos = If ( Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1 ; 1; 0)

 

Misschien dat iemand nog iets weet voor "kleine doos" zonder if-constructie.

 

PJ

Link to comment
  • 0

kleine doos = If ( Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1 ; 1; 0)

 

Yep, uit een test komt al 0 of 1 waaruit volgt:

kleine doos = Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1

 

Maar er kan maximaal 1 kleine doos berekend kan worden.

 

Groet,

René

Link to comment
  • 0

Ik probeer hier een configuratie te berekenen met zo min mogelijk plaats in de dozen. (Restwaarde)

 

Ik geef toe dat ik aanvankelijk meer in de richting van het berekenen van wisselgeld zat te denken, en dat is in dit voorbeeld niet helemaal bruikbaar. Maar er moet toch een 'mooie' formule voor zijn! :-)

 

Geef eens een oplage waarmee mijn aangepaste versie de fout in gaat, want ik ben nog niet helemaal overtuigd dat je formule echt nodig is.

 

Groet,

René

Link to comment
  • 0
Bij een oplage van 1875 krijg ik bij jouw formule het volgende:

Dozen Middel: 2

Dozen Klein: -1

 

Aha, dat kan opgelost worden door voor het veld Dozen Klein te gebruiken:

 

Max(
 Ceiling((Aantal Oplage - (Dozen Groot * 2500) - (Dozen Middel * 1250)) / 500 );

 0
)

 

René

Link to comment
  • 0
Ja lost inderdaad dit probleem op. Bij de meeste oplages is de uitkomst dezelfde. Toch zijn de uitkomsten hier en daar verschillend.

 

Hallo Koen,

 

Inderdaad gezien, heb nu 1,5 avond lopen rekenen en proberen. Cirkelredenering is een probleem. En bij het meer generiek maken in herhaalde velden gaat e.e.a. technisch niet goed.

 

Kom er echter achter dat jouw berekening hier en daar ook niet klopt.

Neem b.v. 4981 stuks waar uit komt: 2x2500 en 1x1250 = totaal 6250

of 7453 stuks met 3x2500 en 1x1250 = totaal 8750

Dat is dus veel meer restruimte dan je berekening laat zien, want de dozen van 2500 stuks zijn voldoende...

 

Ik werk nog aan een oplossing.

 

Groet,

René

Link to comment
  • 0

Er zat inderdaad nog een bugje in. Allemaal in de conditie wanneer er alleen dozen zouden moeten zijn. In volgende formule is dit gecorrigeerd:

 

Let 
( 
[ 
oplage =  Aantal Oplage
; 
floordoos1 = Floor(Oplage / 2500) 
; 
ceilingdoos1 = Ceiling(Oplage / 2500) 
; 
restdoos1 = (ceilingdoos1 * 2500) - Oplage 
; 
floordoos2 = Floor((Oplage -(floordoos1 * 2500) ) / 1250) 
; 
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * 2500) ) / 1250) 
; 
restdoos2 = (floordoos1 * 2500) + (ceilingdoos2 * 1250) - Oplage 
; 
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * 2500)  -(floordoos2 * 1250) ) / 500) 
; 
restdoos3 = (floordoos1 * 2500) + (floordoos2 * 1250) + (ceilingdoos3 * 500) - Oplage 
; 
minrest =  Min(restdoos1; restdoos2; restdoos3) 
; 
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1) 
; 
doos2 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2) 
; 
doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3) 
; 
result = "Groot: " & doos1 & "¶" & "Middel: " & doos2 & "¶" & "Klein: " & doos3 & "¶" 
] 
; 
result 

)

 

Ik kijk uit naar je alternatief René.

 

 

Koen

Link to comment
  • 0

Ik kijk uit naar je alternatief René.

 

Ik was nog bezig maar dat is geen belofte dat er een beter alternatief uit komt! :-)

 

Op bijna 10 verschillende manieren heb ik getracht tot de uitkomst te komen. Overigens, mijn oorspronkelijke berekening is in 80% van de gevallen optimaal. (En 100% als het om geldmiddelen gaat.)

 

Maar bij elke poging blijkt dat je alle mogelijkheden moet berekenen om de beste uit te kiezen. Met drie formaten dozen is dat nog wel redelijk te doen. Zie hier overigens nog wel iets leuks met het in tekst berekenen van de berekening en met Evaluate() uitvoeren! Maar ga daar even geen onbetaalde tijd instoppen.

Schrijf maar eens uit hoe je zo'n opdracht handmatig zou doen, op een bepaald moment schat je of nog een doos genomen moet worden of (meerdere) kleine geschikt zijn. En schatten, dat kan een computer niet...

 

Het enige punt van verbetering in de formule is dat de drie waarden los te benaderen moeten zijn. Dan kan je drie berekeningvelden nemen met vrijwel dezelfde formule (met Eigen Functie), maar dat kost ook 3x zoveel tijd. Zie toegevoegd bestandje voor meer generieke berekening en twee mogelijkheden van uitlezen (een alleen-FM8 functie gebruikt).

 

Groet,

René

 

P.S. Mogen we hier overigens aannemen dat iedereen FM Developer/Advanced heeft en Eigen Functies enzo in de voorbeelden gebruikt kunnen worden?

Dozen demo v2.zip

Link to comment
  • 0

Voor het gemak van de mensen die geen Advanced versie hebben, hier de custom functie van René. Inderdaad een mooi ding.

Let (
 [floordoos1 = Floor(Oplage / Inhoud_1);
 ceilingdoos1 = Ceiling(Oplage / Inhoud_1);
 restdoos1 = (ceilingdoos1 * Inhoud_1) - Oplage;

 floordoos2 = Floor((Oplage -(floordoos1 * Inhoud_1) ) / Inhoud_2);
 ceilingdoos2 = Ceiling((Oplage -(floordoos1 * Inhoud_1) ) / Inhoud_2);
 restdoos2 = (floordoos1 * Inhoud_1) + (ceilingdoos2 * Inhoud_2) - Oplage;

 ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * Inhoud_1)  -(floordoos2 * Inhoud_2) ) / Inhoud_3);
 restdoos3 = (floordoos1 * Inhoud_1) + (floordoos2 * Inhoud_2) + (ceilingdoos3 * Inhoud_3) - Oplage;

 minrest =  Min(restdoos1; restdoos2; restdoos3);

 doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1);
 doos2 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2);
 doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3)
];

Choose ( Doosnr ; doos1 & "¶" & doos2 & "¶" & doos3; doos1 ; doos2; doos3)

)

Link to comment

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
×
  • Create New...