diff --git a/db/db1100.cpp b/db/db1100.cpp
index b581921cd..2be9e79e2 100755
--- a/db/db1100.cpp
+++ b/db/db1100.cpp
@@ -812,7 +812,7 @@ bool TExplode_distinta_form::validate(TForm_item &f, TToken_string &t)
       {
         case 'A':
         {
-          valore = _art_cache.get(re.articolo()).get(code);
+          valore = cache().get(LF_ANAMAG, re.articolo(), code);
           break;
         }
         case 'L':
@@ -864,7 +864,7 @@ bool TExplode_distinta_form::validate(TForm_item &f, TToken_string &t)
         {
           case 'A':
           {
-            valore = _art_cache.get(re.articolo()).get(ANAMAG_DESCR);
+            valore = cache().get(LF_ANAMAG, re.articolo(), ANAMAG_DESCR);
             break;
           }
           case 'L':
@@ -952,7 +952,7 @@ bool TExplode_distinta_form::validate(TForm_item &f, TToken_string &t)
                               else
                                 if (code == "_CODFORN")
                                 {                      
-                                  valore = _art_cache.get(re.articolo()).get(ANAMAG_CODFORN);
+                                  valore = cache().get(LF_ANAMAG, re.articolo(), ANAMAG_CODFORN);
                                 }
                                 else
                                   if (code == "_CODCORR")
diff --git a/db/dblib.cpp b/db/dblib.cpp
index 9f1d888b3..bcf67b97c 100755
--- a/db/dblib.cpp
+++ b/db/dblib.cpp
@@ -17,33 +17,31 @@
 // TQuantita' 
 ///////////////////////////////////////////////////////////
 
-real TQuantita::get_factor(const TCodice_um& um) const
+const fraction& TQuantita::get_factor(const TCodice_um& um) const
 {
-  real fc = 1.0;
-  if (_articolo.blank())
+  static TAssoc_array factors;
+    
+  TString80 code;
+  code << _articolo << '|' << (um.empty() ? _um : um);
+  
+  fraction* conv = (fraction*)factors.objptr(code);
+  if (conv == NULL)
   {
-    NFCHECK("Unita' di misura generica non supportata");
+    TLocalisamfile umart(LF_UMART);
+    umart.setkey(2);
+    umart.put(UMART_CODART, _articolo);
+    umart.put(UMART_UM, um.empty() ? _um : um);
+    if (umart.read() == NOERR)
+      conv = new fraction(umart.get_real(UMART_FC), UNO);
+    else
+      conv = new fraction(1,1);
+    factors.add(code, conv);
   }
-  else
-  {
-    static TDecoder* umart2 = NULL;
-    if (umart2 == NULL)
-    {
-      umart2 = new TDecoder(LF_UMART, UMART_FC, 2);
-      umart2->test_file_changes();
-      umart2->set_items_limit(512);
-    }
-
-    TString80 code;
-    code << _articolo << '|' << (um.empty() ? _um : um);
-    const TString& val = umart2->decode(code);
-    if (val.not_empty())
-      fc = real(val);
-  }
-  return fc;
+  
+  return *conv;
 }
 
-real TQuantita::find_umbase(TCodice_um& um)
+void TQuantita::find_umbase(TCodice_um& um) const
 {
   TString80 code;
   code << _articolo << "|1"; 
@@ -52,13 +50,13 @@ real TQuantita::find_umbase(TCodice_um& um)
     um = cache().get("LAV", _articolo, "S6");
   else
     um = new_um;
-  return 1.0;
 }
 
-real TQuantita::find_umdist(TCodice_um& um)
+void TQuantita::find_umdist(TCodice_um& um) const
 {
   um = cache().get(LF_DIST, _articolo, UMART_UM);
-  return um.blank() ? find_umbase(um) : get_factor(um);
+  if (um.blank()) 
+    find_umbase(um);
 }
 
 void TQuantita::set_articolo(const TString& art, const TString& um) 
@@ -66,41 +64,34 @@ void TQuantita::set_articolo(const TString& art, const TString& um)
   _articolo = art;
 
   if (isalnum(um[0]))
-  {
     _um = um;
-    _conv = get_factor(_um);
-  }
   else
   {
     if (um.blank())
-      _conv = find_umbase(_um);
+      find_umbase(_um);
     else
-      _conv = find_umdist(_um);
+      find_umdist(_um);
   }
 
   if (!art.blank() && _um.blank())
     NFCHECK("Unita' di misura nulla per %s", (const char*)art);
-  CHECK(_conv > ZERO, "Invalid conversion factor");
 }
 
 void TQuantita::copy(const TQuantita& q)
 {
   _articolo = q._articolo;
   _um = q._um;
-  _conv = q._conv;
   _val = q._val;
 }
 
-void TQuantita::convert(real& val, const TCodice_um& from_um, 
-                                   const TCodice_um& to_um) const
+void TQuantita::convert(real& val, const TCodice_um& from_um, const TCodice_um& to_um) const
 {
   CHECK(!from_um.blank() && !to_um.blank(), "Unita' di misura nulla");
   if (from_um != to_um && !val.is_zero())
   {
-    const real mul = get_factor(from_um);
-    const real div = get_factor(to_um);
-    val *= mul;         
-    val /= div;       
+    const fraction& mul = get_factor(from_um);
+    const fraction& div = get_factor(to_um);
+    val =  fraction(val, UNO) * mul / div;         
     TArticolo::round_um(val, to_um);
   }
 }
@@ -108,7 +99,7 @@ void TQuantita::convert(real& val, const TCodice_um& from_um,
 void TQuantita::convert2umdist()
 {
   TCodice_um dummy;
-  _conv = find_umdist(dummy);
+  find_umdist(dummy);
   if (dummy != _um)
   {
     convert(_val, _um, dummy);
@@ -122,20 +113,22 @@ void TQuantita::convert2umbase()
   find_umbase(dummy);
   if (dummy != _um)
   {
-    CHECK(_conv > ZERO, "Invalid conversion factor");
-    _val *= _conv;
+    convert(_val, _um, dummy);
     _um = dummy;
-    _conv = 1.0;
-    TArticolo::round_um(_val, _um);
   }
 }
 
 real TQuantita::base_val() const
 {
-  CHECK(_conv > ZERO, "Invalid conversion factor");
-  real v = _conv * _val;
-  TArticolo::round_um(v, _um);
-  return v;
+  TCodice_um dummy;
+  find_umbase(dummy);
+  if (dummy != _um)  // Se non sono gia' la base...
+  {
+    real v = _val;
+    convert(v, _um, dummy);
+    return v;
+  }
+  return _val;
 }
 
 int TQuantita::compare(const TSortable& s) const
@@ -206,7 +199,6 @@ const TQuantita& TQuantita::operator /=(const real& q)
 }
 
 TQuantita::TQuantita() 
-         : _conv(1.0) 
 { }
 
 TQuantita::TQuantita(const TString& art, const TString&  um, const real& val) 
diff --git a/db/dblib.h b/db/dblib.h
index aa93626fc..b59ac6cf5 100755
--- a/db/dblib.h
+++ b/db/dblib.h
@@ -5,6 +5,10 @@
 #include <expr.h>
 #endif
 
+#ifndef __FRACTION_H
+#include <fraction.h>
+#endif
+
 #ifndef __RECARRAY_H
 #include <recarray.h>
 #endif
@@ -147,7 +151,6 @@ class TQuantita : public TSortable
 {
   TCodice_articolo _articolo;  // Articolo di riferimento
   TCodice_um       _um;        // Unita' di misura
-  real             _conv;      // Fattore di conversione alla base
   real             _val;       // Valore attuale
 
 protected:
@@ -155,11 +158,11 @@ protected:
   virtual TObject* dup() const { return new TQuantita(*this); }
 
   void copy(const TQuantita& q);
-  real get_factor(const TCodice_um& um) const;
+  const fraction& get_factor(const TCodice_um& um) const;
   void convert(real& val, const TCodice_um& from_um, const TCodice_um& to_um) const;
 
-  real find_umbase(TCodice_um& um);
-  real find_umdist(TCodice_um& um);
+  void find_umbase(TCodice_um& um) const;
+  void find_umdist(TCodice_um& um) const;
 
 public:
   virtual bool ok() const { return !_um.blank(); }
@@ -177,7 +180,6 @@ public:
 
   const TCodice_articolo& articolo() const { return _articolo; }
   const TCodice_um& um() const { return _um; }
-  const real& conv() const { return _conv; }
   const real& val() const  { return _val;  }
   real base_val() const;