Denisson ABLeal
Denisson ABLeal
Juazeiro - BA
2014
UNIVERSIDADE FEDERAL DO VALE DO SÃO FRANCISCO
CURSO DE GRADUAÇÃO EM ENGENHARIA DA COMPUTAÇÃO
Juazeiro - BA
2014
Denisson Augusto Bastos Leal
Sistema de Formulação de Ração/ Denisson Augusto Bastos Leal. – Juazeiro -
BA, 7 de março de 2014
Orientador: Dr. Brauliro Gonçalves Leal
CDU 02:141:005.7
UNIVERSIDADE FEDERAL DO VALE DO SÃO FRANCISCO
CURSO DE GRADUAÇÃO EM ENGENHARIA DA COMPUTAÇÃO
FOLHA DE APROVAÇÃO
A minha família, por todo amor, carinho e exemplo que me deram. Meus amigos
Henrique Menezes, Núbia Araújo, Cintia Araujo e Artenia Almeida. Meus professores, em
especial Brauliro Leal, pelo apoio e paciência.
“Aquele que diz que pode e aquele que diz
que não pode tem ambos razão”.
Confúcio, filósofo chinês (551 a.C. - 479 a.C.)
Lista de abreviaturas e siglas
TI Tecnologia da Informação
MS Matéria Seca
PB Proteína Bruta
Ca Cálcio
P Fósforo
PL Programação Linear
Lista de ilustrações . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Lista de tabelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.1 Objetivo Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.2 Objetivo Específico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2 Nutrição Animal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1 Exigências nutricionais . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2 Composição dos alimentos . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3 Formulação de Rações . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 Métodos Manuais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3.2 Método Computacional . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 Programação Linear . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1 Forma Padrão e Forma Relaxada . . . . . . . . . . . . . . . . . . . . . . 29
3.2 Algoritmo Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4 Materiais e Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.1 Tabelas de Exigências Nutricionais . . . . . . . . . . . . . . . . . . . . . 35
4.2 Linguagem Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Classe Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4 Ferramentas Utilizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4.1 Editor de Diagramas DIA . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4.2 IDE NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5 Planejamento de Software . . . . . . . . . . . . . . . . . . . . . . . 39
5.1 Caso de Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 Diagrama de Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.3 Estrutura dos Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.4 Protótipo de Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6 Conclusão e Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . 49
Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
ANEXO A – Código Fonte da Classe Simplex . . . . . . . . . . . . 53
Lista de ilustrações
1 Introdução
Este trabalho tem como objetivo modelar e desenvolver um sistema que, dado um
animal e os alimentos disponíveis com seus respectivos preços, faça um balanceamento de
nutrientes, com o menor custo possível.
22 Capítulo 1. Introdução
• Estruturar dados da forma mais genérica possível, para possibilitar inserção de novas
tabelas nutricionais;
• Montar uma interface simples e amigável, para que os usuários consigam usar sem
dificuldades.
23
2 Nutrição Animal
Nutrientes Quantidade
Energia Metabolizável 2.950 kcal/kg
Proteína 22,20 %
Cálcio 0,920 %
Fósforo Disponível 0,470 %
Fósforo Digestível 0,395 %
Sódio 0,220 %
Lisina Dig. 1,310 %
Metionina Dig. 0,511 %
Metionina + Cistina Dig 0,944 %
Treonina Dig 0,852 %
Triptofano Dig 0,223 %
Arginina Dig 1,415 %
Glicina + Serina Dig 1,926 %
Valina Dig 1,009 %
Isoleucina Dig 0,878 %
Existe dois diferentes tipos de sistemas gástricos: o monogástrico que possui apenas
um estomago que é responsável pelo processo de quebra do alimento e o ruminante que
24 Capítulo 2. Nutrição Animal
possui vários estômagos cada um com funções digestivas diferentes, por essa razão são
chamados também de poligástrico.
• Caracterizar o animal
Consiste em classificar o animal de acordo com fatores que influenciem na sua dieta,
como idade e peso.
• Definir as exigências
• Seleção de alimentos
Deve ser escolhido um método de acordo com a conveniência e com a precisão desejada,
adiante está descrito as características de alguns dos métodos mais utilizados.
26 Capítulo 2. Nutrição Animal
NA1 |E − NA2 |
NA2 |E − NA1 |
|E − NA2 | + |E − NA1 |
|E − NA1 |
Alimento 1 = 100 (2.1)
|E − NA2 | + |E − NA1 |
|E − NA2 |
Alimento 2 = 100 (2.2)
|E − NA2 | + |E − NA1 |
A1 + A2 + Z = 100
(2.3)
A1 NA1 + A2 NA2 = E
2.3. Formulação de Rações 27
3 Programação Linear
a0 x0 + a1 x1 + ... + an xn (3.1)
onde
x0 , x1 , x2 , ..., xn ≥ 0 (3.3)
As equações 3.1, 3.2 e 3.3 são conhecidas como a Forma Padrão de um problema
de programação linear (CORMEN, 2002). Para um caso bidimensional, as restrições são
retas que limitam o plano xy formando assim uma região de interseção, como mostra a
Figura 3.
por
Pn
j=1 aij xj ≥ bi
Pn (3.5)
j=1 aij xj ≤ bi
Note que a única forma de satisfazer as duas equações é estando numa condição de
igualdade (CORMEN, 2002).
Em seguida, as restrições de maior que ou igual serão convertidas em menor que
ou igual. Para isso basta multiplicar por −1, ou seja, quando temos
n
X
aij xj ≥ bi (3.6)
j=1
transformamos na equivalência
n
X
−aij xj ≤ −bi (3.7)
j=1
onde xn+i ≥ 0. xn+i é chamada de variável relaxada porque ela mede a folga entre os lados
esquerdo e direito da equação (CORMEN, 2002).
4 Materiais e Métodos
Fonte Animais
NRC (2000) Gado de corte
NRC (2001) Gado de leite
NRC (2007) Cavalos e caprinos
Rostagno et al. (2011) Aves e suínos
5 Planejamento de Software
• Atores:
– Usuário;
– Servidor.
• Pré-condição:
• Pós-condição:
• Atores:
– Usuário.
• Pré-condição:
• Pós-condição:
• Atores:
– Usuário.
• Pré-condição:
• Pós-condição:
• Atores:
– Usuário.
• Pré-condição:
• Pós-condição:
– Animal selecionado.
• Atores:
– Usuário.
• Pré-condição:
– O sistema deve listar todos os alimentos disponíveis com suas principais carac-
terísticas;
– O usuário informa quais devem ser utilizados na formulação;
44 Capítulo 5. Planejamento de Software
• Pós-condição:
• Atores:
– Usuário.
• Pré-condição:
• Pós-condição:
dados antigos que serão carregados. O Manual e o Sobre fazem parte da opção Ajuda.
48 Capítulo 5. Planejamento de Software
2. Coleta de dados.
3. Planejamento de Software.
5. Desenvolvimento do Software.
6. Aplicação de testes.
7. Implantação.
Referências
ANDRIGUETTO, J. M. Nutrição animal. São Paulo: Nobel, 1981. Citado 3 vezes nas
páginas 23, 24 e 25.
AVESUI: Produção de frango é a que mais deve crescer no Brasil na próxima década. 2012.
Avicultura Industrial. Disponível em: <http://www.aviculturaindustrial.com.br/noticia/
avesui-producao-de-frango-e-a-que-mais-deve-crescer-no-brasil-na-proxima-decada/
20120402164314_G_456>. Acesso em: 05 mar. 2014. Citado na página 21.
CULLISON, A. E. Feeds and Feeding. Athens, Georgia: A Prentice Hall Company, 1975.
Citado na página 25.
DEITEL, H. M. Java: como programar. São Paulo: Pearson Prentice Hall, 2005. Citado
na página 35.
GUEDES, G. T. A. UML: Uma abordagem prática. São Paulo: Novatec, 2004. Citado na
página 39.
JACOUOT, R. et al. Nutrition Animale. J.B. Bailliere: Paris, 1958. Citado na página 24.
NRC: Nutrient requirements of beef cattle. 7. ed. Washinton: D.C., 2000. Citado na
página 35.
NRC: Nutrient requeriments of dairy cattle. 7. ed. Washinton: D.C., 2001. Citado 2 vezes
nas páginas 23 e 35.
NRC: Nutrient requirements of horses. 6. ed. Washinton: D.C., 2007. Citado 2 vezes nas
páginas 24 e 35.
1 /∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗
2 ∗ Compilation : javac Simplex . java
3 ∗ Execution : java Simplex
4 ∗
5 ∗ Given an M−by−N m a t r i x A, an M−l e n g t h v e c t o r b , and an
6 ∗ N−l e n g t h v e c t o r c , s o l v e t h e LP { max cx : Ax <= b , x >= 0 } .
7 ∗ Assumes t h a t b >= 0 so t h a t x = 0 i s a b a s i c f e a s i b l e s o l u t i o n .
8 ∗
9 ∗ C r e a t e s an (M+1)−by −(N+M+1) s i m p l e x t a b l e a u x w i t h t h e
10 ∗ RHS i n column M+N, t h e o b j e c t i v e f u n c t i o n i n row M, and
11 ∗ s l a c k v a r i a b l e s i n columns M t h r o u g h M+N−1.
12 ∗
13 ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/
14
15 public c l a s s Simplex {
16 private s t a t i c f i n a l double EPSILON = 1 . 0 E−10;
17 private double [ ] [ ] a ; // t a b l e a u x
18 private int M; // number o f c o n s t r a i n t s
19 private int N; // number o f o r i g i n a l v a r i a b l e s
20
21 private int [ ] b a s i s ; // b a s i s [ i ] = b a s i c v a r i a b l e c o r r e s p o n d i n g t o
row i
22 // o n l y needed t o p r i n t o u t s o l u t i o n , not book
23
24 // s e t s up t h e s i m p l e x t a b l e a u x
25 public Simplex ( double [ ] [ ] A, double [ ] b , double [ ] c ) {
26 M = b . length ;
27 N = c . length ;
28 a = new double [M+ 1 ] [N+M+ 1 ] ;
29 f o r ( int i = 0 ; i < M; i ++)
30 f o r ( int j = 0 ; j < N; j ++)
31 a [ i ] [ j ] = A[ i ] [ j ] ;
32 f o r ( int i = 0 ; i < M; i ++) a [ i ] [ N+i ] = 1 . 0 ;
33 f o r ( int j = 0 ; j < N; j ++) a [M] [ j ] = c[ j ];
34 f o r ( int i = 0 ; i < M; i ++) a [ i ] [M+N] = b [ i ] ;
35
36 b a s i s = new int [M] ;
37 f o r ( int i = 0 ; i < M; i ++) b a s i s [ i ] = N + i ;
38
39 solve () ;
54 ANEXO A. Código Fonte da Classe Simplex
40
41 // c h e c k o p t i m a l i t y c o n d i t i o n s
42 a s s e r t check (A, b , c ) ;
43 }
44
45 // run s i m p l e x a l g o r i t h m s t a r t i n g from i n i t i a l BFS
46 private void s o l v e ( ) {
47 while ( true ) {
48
49 // f i n d e n t e r i n g column q
50 int q = bland ( ) ;
51 i f ( q == −1) break ; // o p t i m a l
52
53 // f i n d l e a v i n g row p
54 int p = minRatioRule ( q ) ;
55 i f ( p == −1) throw new A r i t h m e t i c E x c e p t i o n ( " L i n e a r program i s
unbounded " ) ;
56
57 // p i v o t
58 pivot (p , q) ;
59
60 // u p d a t e b a s i s
61 basis [p] = q ;
62 }
63 }
64
65 // l o w e s t i n d e x o f a non−b a s i c column w i t h a p o s i t i v e c o s t
66 private int bland ( ) {
67 f o r ( int j = 0 ; j < M + N; j ++)
68 i f ( a [M] [ j ] > 0 ) return j ;
69 return −1; // o p t i m a l
70 }
71
72 // i n d e x o f a non−b a s i c column w i t h most p o s i t i v e c o s t
73 private int d a n t z i g ( ) {
74 int q = 0;
75 for ( int j = 1 ; j < M + N; j ++)
76 i f ( a [M] [ j ] > a [M] [ q ] ) q = j ;
77
78 i f ( a [M] [ q ] <= 0 ) return −1; // o p t i m a l
79 e l s e return q ;
80 }
81
82 // f i n d row p u s i n g min r a t i o r u l e (−1 i f no such row )
83 private int minRatioRule ( int q ) {
84 int p = −1;
85 for ( int i = 0 ; i < M; i ++) {
55
86 i f ( a [ i ] [ q ] <= 0 ) continue ;
87 e l s e i f ( p == −1) p = i ;
88 e l s e i f ( ( a [ i ] [M+N] / a [ i ] [ q ] ) < ( a [ p ] [M+N] / a [ p ] [ q ] ) ) p = i ;
89 }
90 return p ;
91 }
92
93 // p i v o t on e n t r y ( p , q ) u s i n g Gauss−Jordan e l i m i n a t i o n
94 private void p i v o t ( int p , int q ) {
95
96 // e v e r y t h i n g b u t row p and column q
97 f o r ( int i = 0 ; i <= M; i ++)
98 f o r ( int j = 0 ; j <= M + N; j ++)
99 i f ( i != p && j != q ) a [ i ] [ j ] −= a [ p ] [ j ] ∗ a [ i ] [ q ] / a [ p ] [ q
];
100
101 // z e r o o u t column q
102 f o r ( int i = 0 ; i <= M; i ++)
103 i f ( i != p ) a [ i ] [ q ] = 0 . 0 ;
104
105 // s c a l e row p
106 f o r ( int j = 0 ; j <= M + N; j ++)
107 i f ( j != q ) a [ p ] [ j ] /= a [ p ] [ q ] ;
108 a[p ][ q] = 1.0;
109 }
110
111 // r e t u r n o p t i m a l o b j e c t i v e v a l u e
112 public double v a l u e ( ) {
113 return −a [M] [M+N ] ;
114 }
115
116 // r e t u r n p r i m a l s o l u t i o n v e c t o r
117 public double [ ] p r i m a l ( ) {
118 double [ ] x = new double [N ] ;
119 f o r ( int i = 0 ; i < M; i ++)
120 i f ( b a s i s [ i ] < N) x [ b a s i s [ i ] ] = a [ i ] [M+N ] ;
121 return x ;
122 }
123
124 // r e t u r n d u a l s o l u t i o n v e c t o r
125 public double [ ] d u a l ( ) {
126 double [ ] y = new double [M] ;
127 f o r ( int i = 0 ; i < M; i ++)
128 y [ i ] = −a [M] [ N+i ] ;
129 return y ;
130 }
131
56 ANEXO A. Código Fonte da Classe Simplex
132
133 // i s t h e s o l u t i o n p r i m a l f e a s i b l e ?
134 private boolean i s P r i m a l F e a s i b l e ( double [ ] [ ] A, double [ ] b ) {
135 double [ ] x = p r i m a l ( ) ;
136
137 // c h e c k t h a t x >= 0
138 f o r ( int j = 0 ; j < x . l e n g t h ; j ++) {
139 if (x [ j ] < 0.0) {
140 StdOut . p r i n t l n ( " x [ " + j + " ] = " + x [ j ] + " i s n e g a t i v e " ) ;
141 return f a l s e ;
142 }
143 }
144
145 // c h e c k t h a t Ax <= b
146 f o r ( int i = 0 ; i < M; i ++) {
147 double sum = 0 . 0 ;
148 f o r ( int j = 0 ; j < N; j ++) {
149 sum += A[ i ] [ j ] ∗ x [ j ] ;
150 }
151 i f ( sum > b [ i ] + EPSILON) {
152 StdOut . p r i n t l n ( " not p r i m a l f e a s i b l e " ) ;
153 StdOut . p r i n t l n ( " b [ " + i + " ] = " + b [ i ] + " , sum = " + sum )
;
154 return f a l s e ;
155 }
156 }
157 return true ;
158 }
159
160 // i s t h e s o l u t i o n d u a l f e a s i b l e ?
161 private boolean i s D u a l F e a s i b l e ( double [ ] [ ] A, double [ ] c ) {
162 double [ ] y = d u a l ( ) ;
163
164 // c h e c k t h a t y >= 0
165 f o r ( int i = 0 ; i < y . l e n g t h ; i ++) {
166 if (y [ i ] < 0.0) {
167 StdOut . p r i n t l n ( " y [ " + i + " ] = " + y [ i ] + " i s n e g a t i v e " ) ;
168 return f a l s e ;
169 }
170 }
171
172 // c h e c k t h a t yA >= c
173 f o r ( int j = 0 ; j < N; j ++) {
174 double sum = 0 . 0 ;
175 f o r ( int i = 0 ; i < M; i ++) {
176 sum += A[ i ] [ j ] ∗ y [ i ] ;
177 }
57
221 }
222 StdOut . p r i n t l n ( " v a l u e = " + v a l u e ( ) ) ;
223 f o r ( int i = 0 ; i < M; i ++)
224 i f ( b a s i s [ i ] < N) StdOut . p r i n t l n ( "x_" + b a s i s [ i ] + " = " + a [ i
] [M+N ] ) ;
225 StdOut . p r i n t l n ( ) ;
226 }
227
228
229 public s t a t i c void t e s t ( double [ ] [ ] A, double [ ] b , double [ ] c ) {
230 Simplex l p = new Simplex (A, b , c ) ;
231 StdOut . p r i n t l n ( " v a l u e = " + l p . v a l u e ( ) ) ;
232 double [ ] x = l p . p r i m a l ( ) ;
233 f o r ( int i = 0 ; i < x . l e n g t h ; i ++)
234 StdOut . p r i n t l n ( " x [ " + i + " ] = " + x [ i ] ) ;
235 double [ ] y = l p . d u a l ( ) ;
236 f o r ( int j = 0 ; j < y . l e n g t h ; j ++)
237 StdOut . p r i n t l n ( " y [ " + j + " ] = " + y [ j ] ) ;
238 }
239
240 public s t a t i c void test1 () {
241 double [ ] [ ] A = {
242 { −1, 1 , 0 },
243 { 1, 4, 0 },
244 { 2, 1, 0 },
245 { 3 , −4, 0 },
246 { 0, 0, 1 },
247 };
248 double [ ] c = { 1 , 1 , 1 };
249 double [ ] b = { 5 , 45 , 27 , 24 , 4 } ;
250 t e s t (A, b , c ) ;
251 }
252
253 // x0 = 12 , x1 = 28 , o p t = 800
254 public s t a t i c void t e s t 2 ( ) {
255 double [ ] c = { 1 3 . 0 , 2 3 . 0 } ;
256 double [ ] b = { 4 8 0 . 0 , 1 6 0 . 0 , 1 1 9 0 . 0 } ;
257 double [ ] [ ] A = {
258 { 5.0 , 15.0 } ,
259 { 4.0 , 4.0 } ,
260 { 35.0 , 20.0 } ,
261 };
262 t e s t (A, b , c ) ;
263 }
264
265 // unbounded
266 public s t a t i c void t e s t 3 ( ) {
59