Arrondir un nombre à l'entier le plus proche inférieur

Version imprimable

21/06/2017, 09h56
PTuner

Arrondir un nombre à l'entier le plus proche inférieur

Bonjour,
Je recherche une fonction de type round() qui m'arrondirait un entier au nombre inférieur le plus proche (de la largeur) c'est pour un programme de découpe de panneaux en acier. Sachant que j'ai dans une liste des longueurs à respecter de type 1370 1250 1500. Quelqu'un connaitrait une fonction ou une méthode pour le faire? Je connais la fonction floor () mais elle ne répond pas exactement à mon problème puisque je veux renvoyer un nombre de la base et non un entier inconnu.
21/06/2017, 10h19
Bousk

Salut,

Citation:

Envoyé par PTuner

je veux renvoyer un nombre de la base et non un entier inconnu.

Tu veux dire que tu as une liste de valeurs et veux retourner la plus élevée sous une valeur donnée ?
Avec tes exemples 1370, 1250 & 1500, si tu as 1501 tu veux 1500, mais si tu as 1499 tu veux 1370 ?

Y'a pas de fonction magique pour ça, mais une simple suite de if fait l'affaire. :weird:

Une petite lookup table ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <array>
using namespace std;
 
int near(int value)
{
    static array<int, 4> lookup_table = {100, 1250, 1370, 1500};
 
    for (int i = lookup_table.size() - 1; i >= 0; --i)
    {
        int neared = lookup_table[i];
        if (neared <= value)
        {
            return neared;
        }
    }
 
    return 0;
}
 
int main()
{
    cout << near(42) << endl;
    cout << near(242) << endl;
    cout << near(1250) << endl;
    cout << near(1255) << endl;
    cout << near(9999) << endl;
}

Oui c'est ça je suis en train de coder ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //traitement for (std::list<int>::iterator it = longeurspieces.begin();it != longeurspieces.end();++it) { for (std::list<int>::iterator itt = entre.begin(); itt != entre.end();++itt) { cout << "actuel" << *itt << endl; if (*it <= *itt) { longeurspiecesfinal.push_front(*it);//std::find(entre.begin(), entre.end(), i); } cout << "avant" << *it << endl; }
En fait si la valeur correspond à cette condition je la mets dans une autre liste dans l'ordre de la saisie

liste saisie de l'utilisateur********liste base de longeurs*********liste de longeurs

1500(1) *********************1379(1)*********************1379(1)
2000(2) *********************4879(2)*********************1379(2)
4000(3) *********************1105(3)*********************1379(3)

basez vous plutôt sur 1379 4879 1105 du coup.

J'ai utilisé ta méthode bktero mais ça ne me renvoie rien voire ça ferme l'appli voici le code modifiée pour mon utilisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
int near(int value)
{
    static array<int, 3> lookup_table = {1105,1379,4879};
 
    for (int i = lookup_table.size() - 1; i >= 0; --i)
    {
        int neared = lookup_table[i];
        if (neared <= value)
        {
            return neared;
        }
    }
 
    return NULL;
}
 
int main()
{
    std::list<int> entre {};
    std::list<int> ::iterator it = entre.begin();
    const int longm(8000);
    int p(0);
    int nb(0);
    int longeurs(0);
    int prec(0);
    std::string type("");
    int valeurs(0);
    std:list<int> longeurspieces {1379,4879,1105};
 
 
 
    if (entre.empty())
    {
        int i = 0;
        //saisie de la liste
        //entre.push_front();
        cout << "Entre le nombre de longeurs à saisir :" << endl;
        cin >> nb;
        cout << "Entrez le type de piece" << endl;
        cin >> type;
 
        while(i < nb)
        {
            ++i;
 
            cout << "Entre la largeur du panneau " << " {" << i << "} "<< endl;
            cin >> p;
            entre.push_front(p);
            //if (p == 8000)
            //{
                //cout << "Longeur max atteinte !" << endl;
            //}
 
 
        }
        entre.reverse();
        //entre.sort(greater<int>());
 
 
 
        //traitement
        for (std::list<int>::iterator itt = entre.begin(); itt != entre.end();++itt)
            {
 
                cout << near(*itt) << endl;
 
 
            }
}

Euh... si si, il existe un algo qui fait ça et qui existe depuis la nuit des temps en C++ ;)
std::upper_bound

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <array>
int bound(int value)
{
    static std::array<int, 4> longueurpieces = {100, 1250, 1370, 1500};
	auto found = std::upper_bound(longueurpieces.begin(), longueurpieces.end(), value);
	if (found != longueurpieces.begin())
		return *(found-1);
	else
		return 0;
}
 
int main()
{
    std::cout << bound(42) << std::endl;
    std::cout << bound(242) << std::endl;
    std::cout << bound(1250) << std::endl;
    std::cout << bound(1255) << std::endl;
    std::cout << bound(9999) << std::endl;
    return 0;
}

21/06/2017, 11h41
PTuner

Sorry les gars j'avais oublié le getch(); :oops: ça marche nickel camboui
21/06/2017, 11h59
PTuner

Excusez moi encore
Vous auriez une idée du coup après avoir saisi tout ça et avoir sélectionne les pièces grâce à la fonction les pièces égales ou inférieures les plus proches de refaire tourner tout ça dans une boucle pour minimiser les pertes car là dans le cas 2000 j'aurai 621mm x 1379 mm de perte soit environ 80 m de surface du panneau.
21/06/2017, 12h46
ternel
là, on passe à un problème d'algorithme d'optimisation.

Ce n'est plus du tout le même problème.
1. Résouds le problème manuellement, avec papier et crayon, pour une liste de pièces précise.
2. prouve que tu l'a résolu,
3. Observe comment tu l'a résolu.
4. Explique le.
5. Généralise ton explication
6. Applique la à une autre liste de pièces.
7. prouve que c'est aussi une bonne solution
Alors seulement tu pourras l'expliquer à l'ordinateur (c'est ca, coder)

Concrètement, il doit exister des réponses sur internet, mais je ne sais pas quoi chercher.
21/06/2017, 13h06
camboui

Ceci dit, j'ai trouvé un commentaire très intéressant je suis codeur (dont C++) et mon père était menuisier.

Citation:

quand je le voyais préparer ses découpes, j'imaginais (avec la vanité de
ma jeunesse) pouvoir optimiser son travail en calculant les coupes.
mais, trait après trait, en voyant qu'il avait, avant même de les
énumérer, déjà pensé à tous ses pièces, à ses marges de découpes et de
redressement (dégauchissages), je me rendais compte que je n'aurais pas
même pensé à préserver le fil du panneau ...
il est des expériences que la modélisation ne remplace pas

Comme quoi la réponse peut être très complexe ;)