public Return<object> CreateVectorSpaceModel(List<InfoGrp_Class> infos, string taskName, Training training)
		{
			int _sizePartition = 0;
			return CreateVectorSpaceModel(infos, taskName, training, _sizePartition);
		}
		public Return<object> CreateVectorSpaceModel(List<InfoGrp_Class> infos, string taskName, Training training, int sizePartition)
		{
			Return<object> _answer = new Return<object>();
			if (infos == null)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(new ArgumentNullException("infos"), this.GetType());
			}
			else
				if (string.IsNullOrWhiteSpace(taskName))
				{
					_answer.theresError = true;
					_answer.error = Utility.GetError(new ArgumentNullException("taskName"), this.GetType());
				}
				else
					if (training == null)
					{
						_answer.theresError = true;
						_answer.error = Utility.GetError(new ArgumentNullException("training"), this.GetType());
					}
					else
						if (sizePartition < 0)
						{
							_answer.theresError = true;
							_answer.error = Utility.GetError(new ArgumentException("can not be lower than zero", "sizePartition"), this.GetType());
						}
						else
						{
							try
							{
								Return<List<string>> _answerCreateVocabulary = CreateVocabulary(infos);
								if (_answerCreateVocabulary.theresError)
								{
									_answer.theresError = true;
									_answer.error = _answerCreateVocabulary.error;
								}
								else
								{
									List<string> _vocabulary = _answerCreateVocabulary.data.OrderBy(p => p).ToList();
									List<InfoGrp_Class> _usefulInfos = infos.Where(i => i.wordsFromVocabulary.Any()).ToList();


									Return<Tuple<SqlTransaction, string, string, string>> _answerCreateTableForTaskTraining = this.grpClassDataAccess.CreateTableForTaskTraining(taskName, training.name);
									if (_answerCreateTableForTaskTraining.theresError)
									{
										_answer.theresError = true;
										_answer.error = _answerCreateTableForTaskTraining.error;
									}
									else
									{
										SqlTransaction _transaction = _answerCreateTableForTaskTraining.data.Item1;
										string _nameForDocumentTable = _answerCreateTableForTaskTraining.data.Item2
												, _nameForWordTable = _answerCreateTableForTaskTraining.data.Item3
												, _nameForVectorSpaceModelTable = _answerCreateTableForTaskTraining.data.Item4;
										int _nextDocumentId = 0, _nextWordId = 0;
										List<Document> _documents = null;
										List<Word> _words = null;

										Stopwatch _stopwatch = new Stopwatch();
										_stopwatch.Start();

										if (!_answer.theresError)
										{
											Return<int> _answerGetNextDocumentId = this.grpClassDataAccess.GetNextDocumentId(_transaction, _nameForDocumentTable);
											if (_answerGetNextDocumentId.theresError)
											{
												_answer.theresError = true;
												_answer.error = _answerGetNextDocumentId.error;
											}
											else
												_nextDocumentId = _answerGetNextDocumentId.data;
										}

										if (!_answer.theresError)
										{
											Return<int> _answerGetNextWordId = this.grpClassDataAccess.GetNextWordId(_transaction, _nameForWordTable);
											if (_answerGetNextWordId.theresError)
											{
												_answer.theresError = true;
												_answer.error = _answerGetNextWordId.error;
											}
											else
												_nextWordId = _answerGetNextWordId.data;
										}

										if (!_answer.theresError)
										{//let's create the documents
											_documents = _usefulInfos.Select(i => new Document()
																				{
																					id = _nextDocumentId++
																					,
																					groupId = i.groupId
																					,
																					language = !i.language.HasValue ? string.Empty : Enum.GetName(typeof(EnumLanguage), i.language.Value)
																					,
																					information = i.information
																					,
																					wordsFromVocabulary = i.wordsFromVocabulary
																				}
																		).ToList();

											Return<int> _answerAddDocuments = this.grpClassDataAccess.AddDocuments(_documents, _transaction, _nameForDocumentTable);
											if (_answerAddDocuments.theresError)
											{
												_answer.theresError = true;
												_answer.error = _answerAddDocuments.error;
											}
										}//let's create the documents

										if (!_answer.theresError)
										{//let's create the words
											_words = _vocabulary.Select(_w => new Word()
																				{
																					id = _nextWordId++
																					,
																					trainingId = training.id
																					,
																					word = _w
																				}
																				)
																		.ToList();

											Return<int> _answerAddWords = this.grpClassDataAccess.AddWords(_words, _transaction, _nameForWordTable);
											if (_answerAddWords.theresError)
											{
												_answer.theresError = true;
												_answer.error = _answerAddWords.error;
											}
										}//let's create the words

										if (!_answer.theresError)
										{//let's create partitions into the documents in order to save memory
											IEnumerable<IGrouping<int, Document>> _groupedUsefulDocuments = _documents.GroupBy(i => i.groupId);
											List<List<Document>> _usefulDocumentsPartitioned = new List<List<Document>>();
											if (sizePartition > 0)
												_usefulDocumentsPartitioned.AddRange(_groupedUsefulDocuments.SelectMany(g => g.ToList().PartitionAccordingSizeOfPartitions(sizePartition)));
											else
												_usefulDocumentsPartitioned.Add(_documents);

											foreach (List<Document> _documentsPartition in _usefulDocumentsPartitioned)
											{//partition to partition
												if (!_answer.theresError)
												{
													_answer = CreateVectorSpaceModel(_documentsPartition, training.id, _words, _transaction, _nameForVectorSpaceModelTable);
												}

												if (_answer.theresError)
													break;
											}//partition to partition
										}//let's create partitions into the documents in order to save memory
										_stopwatch.Stop();

										if (_answer.theresError)
											_transaction.Rollback();
										else
											_transaction.Commit();
									}
								}
							}
							catch (Exception _ex)
							{
								_answer.theresError = true;
								_answer.error = Utility.GetError(_ex, this.GetType());
							}
						}
			return _answer;
		}
		public Return<List<List<BlatellaGroup>>> Group(string taskName, Training entity)
		{
			Return<List<List<BlatellaGroup>>> _answer = new Return<List<List<BlatellaGroup>>>() { data = new List<List<BlatellaGroup>>() };
			if (entity == null)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(new ArgumentNullException("entity"), this.GetType());
			}
			else
			{
				try
				{
					List<Document> _documents = new List<Document>();
					List<Word> _words = new List<Word>();
					List<VectorSpaceModel> _vectorSpaceModels = new List<VectorSpaceModel>();

					if (!_answer.theresError)
					{
						Return<List<Document>> _answerGetDocumentsForTraining = this.grpClassDataAccess.GetDocumentsForTraining(taskName, entity);
						if (_answerGetDocumentsForTraining.theresError)
						{
							_answer.theresError = true;
							_answer.error = _answerGetDocumentsForTraining.error;
						}
						else
							_documents = _answerGetDocumentsForTraining.data;
					}

					if (!_answer.theresError)
					{
						Return<List<Word>> _answerGetWordsForTraining = this.grpClassDataAccess.GetWordsForTraining(taskName, entity);
						if (_answerGetWordsForTraining.theresError)
						{
							_answer.theresError = true;
							_answer.error = _answerGetWordsForTraining.error;
						}
						else
							_words = _answerGetWordsForTraining.data;
					}

					if (!_answer.theresError)
					{
						Return<List<VectorSpaceModel>> _answerGetVectorSpaceModelsForTraining = this.grpClassDataAccess.GetVectorSpaceModelsForTraining(taskName, entity);
						if (_answerGetVectorSpaceModelsForTraining.theresError)
						{
							_answer.theresError = true;
							_answer.error = _answerGetVectorSpaceModelsForTraining.error;
						}
						else
							_vectorSpaceModels = _answerGetVectorSpaceModelsForTraining.data;
					}

					if (!_answer.theresError && _documents.Any() && _words.Any() && _vectorSpaceModels.Any())
					{
						_documents.ForEach(e => e.vectorSpaceModel = _vectorSpaceModels.Where(v => v.documentId == e.id).ToList());
						_words.ForEach(e => e.vectorSpaceModel = _vectorSpaceModels.Where(v => v.documentId == e.id).ToList());
						Return<SortedList<int, SortedList<int, ICharacteristic>>> _answerGetBinaryCharacteristics = GetBinaryCharacteristics(_documents, _words);
						if (_answerGetBinaryCharacteristics.theresError)
						{
							_answer.theresError = true;
							_answer.error = _answerGetBinaryCharacteristics.error;
						}
						else
						{
							Return<List<List<BlatellaGroup>>> _answerGrouping = this.groupingUtility.Grouping(_answerGetBinaryCharacteristics.data);
							if (_answerGrouping.theresError)
							{
								_answer.theresError = true;
								_answer.error = _answerGrouping.error;
							}
							else
							{
								foreach (List<BlatellaGroup> _clustering in _answerGrouping.data)
								{//clustering to clustering
									List<BlatellaGroup> _newDocumentClustering = new List<BlatellaGroup>();
									foreach (BlatellaGroup _cluster in _clustering)
									{//cluster to cluster
										Return<object> _answerChangeIdsByDocuments = ChangeIdsByDocuments(_cluster, _documents);
										if (_answerChangeIdsByDocuments.theresError)
										{
											_answer.theresError = true;
											_answer.error = _answerChangeIdsByDocuments.error;
										}

										if (_answer.theresError)
											break;
									}//cluster to cluster
									if (_answer.theresError)
										break;
								}//clustering to clustering

								if (!_answer.theresError)
									_answer.data = _answerGrouping.data;
							}
						}
					}
				}
				catch (Exception _ex)
				{
					_answer.theresError = true;
					_answer.error = Utility.GetError(_ex, this.GetType());
				}
			}
			return _answer;
		}
		public Return<int> UpdateTraining(Training entity)
		{
			Return<int> _answer = new Return<int>() { data = 0 };
			if (entity == null)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(new ArgumentNullException("entity"), this.GetType());
			}
			else
			{
				try
				{
					entity.lastModificationDate = DateTime.Now;
					_answer = this.grpClassDataAccess.UpdateTraining(entity);
				}
				catch (Exception _ex)
				{
					_answer.theresError = true;
					_answer.error = Utility.GetError(_ex, this.GetType());
				}
			}
			return _answer;
		}
		public Return<List<VectorSpaceModel>> GetVectorSpaceModelsForTraining(string taskName, Training entity)
		{
			Return<List<VectorSpaceModel>> _answer = new Return<List<VectorSpaceModel>>() { data = new List<VectorSpaceModel>() };
			Return<SqlConnection> _answerConnection = this.connection;
			if (_answerConnection.theresError)
			{
				_answer.theresError = true;
				_answer.error = _answerConnection.error;
			}
			else
			{
				try
				{
					string _nameForVectorSpaceModelTable = GenerateDynamicNameForVectorSpaceModelTable(taskName, entity.name);
					using (SqlConnection _connection = _answerConnection.data)
					{
						if (_connection.State != ConnectionState.Open)
							_connection.Open();
						using (SqlCommand _command = new SqlCommand() { CommandType = CommandType.Text, Connection = _connection, CommandTimeout = timeoutInSecondsBD })
						{//using SqlCommand
							string _fields = string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13}"
														, SQLGrp_Class.FLD_VSM_DOCUMENTID, SQLGrp_Class.FLD_VSM_WORDID, SQLGrp_Class.FLD_VSM_WEIGHT_BINARY, SQLGrp_Class.FLD_VSM_WEIGHT_TERMFREQUENCY
														, SQLGrp_Class.FLD_VSM_WEIGHT_WEIGHTEDTERMFREQUENCY, SQLGrp_Class.FLD_VSM_WEIGHT_AUGMENTEDNORMALIZEDTERMFREQUENCY, SQLGrp_Class.FLD_VSM_WEIGHT_LOGARITHMIC
														, SQLGrp_Class.FLD_VSM_WEIGHT_INVERSEDOCUMENTFREQUENCY, SQLGrp_Class.FLD_VSM_WEIGHT_TF_IDF, SQLGrp_Class.FLD_VSM_WEIGHT_PROBABILISTICINVERSEFREQUENCY
														, SQLGrp_Class.FLD_VSM_WEIGHT_NORMALFUNCTION, SQLGrp_Class.FLD_VSM_WEIGHT_GF_IDF, SQLGrp_Class.FLD_VSM_WEIGHT_ENTROPY, SQLGrp_Class.FLD_VSM_WEIGHT_WEIGHTEDINVERSEFREQUENCY);

							_command.CommandText = string.Format("select {0} from {1}", _fields, _nameForVectorSpaceModelTable);
							using (SqlDataReader _dataReader = _command.ExecuteReader())
							{
								using (DataTable _table = new DataTable())
								{
									_table.Load(_dataReader);
									_answer = DataRowCollectionToVectorSpaceModel(_table.Rows);
								}
							}
						}//using SqlCommand
					}
				}
				catch (Exception _ex)
				{
					_answer.theresError = true;
					_answer.error = Utility.GetError(_ex, this.GetType());
				}
			}
			return _answer;
		}
		public Return<List<Word>> GetWordsForTraining(string taskName, Training entity)
		{
			Return<List<Word>> _answer = new Return<List<Word>>() { data = new List<Word>() };
			Return<SqlConnection> _answerConnection = this.connection;
			if (_answerConnection.theresError)
			{
				_answer.theresError = true;
				_answer.error = _answerConnection.error;
			}
			else
			{
				try
				{
					string _nameForWordTable = GenerateDynamicNameForWordTable(taskName, entity.name);
					using (SqlConnection _connection = _answerConnection.data)
					{
						if (_connection.State != ConnectionState.Open)
							_connection.Open();
						using (SqlCommand _command = new SqlCommand() { CommandType = CommandType.Text, Connection = _connection, CommandTimeout = timeoutInSecondsBD })
						{//using SqlCommand
							string _fields = string.Format("{0},{1},{2}"
														, SQLGrp_Class.FLD_WORD_ID, SQLGrp_Class.FLD_WORD_TRAININGID, SQLGrp_Class.FLD_WORD_WORD);

							_command.CommandText = string.Format("select {0} from {1}", _fields, _nameForWordTable);
							using (SqlDataReader _dataReader = _command.ExecuteReader())
							{
								using (DataTable _table = new DataTable())
								{
									_table.Load(_dataReader);
									_answer = DataRowCollectionToWord(_table.Rows);
								}
							}
						}//using SqlCommand
					}
				}
				catch (Exception _ex)
				{
					_answer.theresError = true;
					_answer.error = Utility.GetError(_ex, this.GetType());
				}
			}
			return _answer;
		}
		public Return<int> UpdateTraining(Training entity)
		{
			Return<int> _answer = new Return<int>() { data = 0 };
			if (entity == null)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(new ArgumentNullException("entity"), this.GetType());
			}
			else
			{
				Return<SqlConnection> _answerConnection = this.connection;
				if (_answerConnection.theresError)
				{
					_answer.theresError = true;
					_answer.error = _answerConnection.error;
				}
				else
				{
					try
					{
						using (SqlConnection _connection = _answerConnection.data)
						{
							if (_connection.State != ConnectionState.Open)
								_connection.Open();
							using (SqlCommand _command = new SqlCommand() { CommandType = CommandType.Text, Connection = _connection, CommandTimeout = timeoutInSecondsBD })
							{//using SqlCommand

								string _fields = string.Format("{0},{1},{2},{3},{4},{5},{6},{7}"
																, SQLGrp_Class.FLD_TRAI_ID, SQLGrp_Class.FLD_TRAI_TASKID, SQLGrp_Class.FLD_TRAI_NAME, SQLGrp_Class.FLD_TRAI_GCTYPE, SQLGrp_Class.FLD_TRAI_GCDESCRIPTION
																, SQLGrp_Class.FLD_TRAI_STATETRAINING, SQLGrp_Class.FLD_TRAI_CREATIONDATE, SQLGrp_Class.FLD_TRAI_LASTMODIFICATIONDATE);

								_command.CommandText = string.Format("update {0} set {2}=@name,{3}=@type,{4}=@description,{5}=@stateTraining,{6}=@creationDate,{7}=@lastModificationDate"
																+ " where {1}=@id"
																, SQLGrp_Class.TAB_TRAINING, SQLGrp_Class.FLD_TRAI_ID, SQLGrp_Class.FLD_TRAI_NAME, SQLGrp_Class.FLD_TRAI_GCTYPE
																, SQLGrp_Class.FLD_TRAI_GCDESCRIPTION, SQLGrp_Class.FLD_TRAI_STATETRAINING, SQLGrp_Class.FLD_TRAI_CREATIONDATE, SQLGrp_Class.FLD_TRAI_LASTMODIFICATIONDATE
																);

								_command.Parameters.AddWithValue("@id", entity.id);
								_command.Parameters.AddWithValue("@name", entity.name);
								_command.Parameters.AddWithValue("@type", entity.type);

								if (entity.description != null)
									_command.Parameters.AddWithValue("@description", entity.description);
								else
									_command.Parameters.AddWithValue("@description", DBNull.Value);

								if (entity.stateTraining != null)
									_command.Parameters.AddWithValue("@stateTraining", entity.stateTraining);
								else
									_command.Parameters.AddWithValue("@stateTraining", DBNull.Value);

								_command.Parameters.AddWithValue("@creationDate", entity.creationDate);
								_command.Parameters.AddWithValue("@lastModificationDate", entity.lastModificationDate);
								_answer.data = _command.ExecuteNonQuery();
							}//using SqlCommand
						}
					}
					catch (Exception _ex)
					{
						_answer.theresError = true;
						_answer.error = Utility.GetError(_ex, this.GetType());
					}
				}
			}
			return _answer;
		}