Commits

Anonymous committed 512d224

Fixed Dat2Dab.cpp: Test for -1 rather than 0 for checking missing values.
Added new tool SpeciesConnector for performing cross-species inference.

Comments (0)

Files changed (9)

proj/vs2008/Sleipnir.sln

 
 Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual Studio 2008
+# Visual C++ Express 2008
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sleipnir", "sleipnir\sleipnir.vcproj", "{772E04C2-CF1E-412B-9BAE-3A4A132837DB}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Dat2Dab", "Dat2Dab\Dat2Dab.vcproj", "{56C30EA3-24DF-4AB4-B68E-17C954F8A816}"
 		{772E04C2-CF1E-412B-9BAE-3A4A132837DB} = {772E04C2-CF1E-412B-9BAE-3A4A132837DB}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SpeciesConnector", "SpeciesConnector\SpeciesConnector.vcproj", "{56C30EA3-24DF-4AB4-B68E-17C954F80000}"
+	ProjectSection(ProjectDependencies) = postProject
+		{772E04C2-CF1E-412B-9BAE-3A4A132837DB} = {772E04C2-CF1E-412B-9BAE-3A4A132837DB}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
 		{56C30EA3-24DF-4AB4-B68E-17C954F8802C}.Debug|Win32.Build.0 = Debug|Win32
 		{56C30EA3-24DF-4AB4-B68E-17C954F8802C}.Release|Win32.ActiveCfg = Release|Win32
 		{56C30EA3-24DF-4AB4-B68E-17C954F8802C}.Release|Win32.Build.0 = Release|Win32
+		{56C30EA3-24DF-4AB4-B68E-17C954F80000}.Debug|Win32.ActiveCfg = Debug|Win32
+		{56C30EA3-24DF-4AB4-B68E-17C954F80000}.Debug|Win32.Build.0 = Debug|Win32
+		{56C30EA3-24DF-4AB4-B68E-17C954F80000}.Release|Win32.ActiveCfg = Release|Win32
+		{56C30EA3-24DF-4AB4-B68E-17C954F80000}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

proj/vs2008/SpeciesConnector/SpeciesConnector.vcproj

+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="SpeciesConnector"
+	ProjectGUID="{56C30EA3-24DF-4AB4-B68E-17C954F80000}"
+	RootNamespace="SpeciesConnector"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+		<ToolFile
+			RelativePath="..\gengetopts.rules"
+		/>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="GenGetOpts"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../../extlib/smile/;&quot;../../../../extlib/gengetopt-2.22/gl/&quot;;../../../src/;&quot;../../../../extlib/pthreads-w32-2-8-0-release/&quot;"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				WarningLevel="3"
+				WarnAsError="true"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="log4cpp.lib"
+				AdditionalLibraryDirectories="../../../../extlib/proj/vs2008/$(ConfigurationName);../../../../extlib/smile/"
+				GenerateDebugInformation="true"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="2"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="GenGetOpts"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				AdditionalIncludeDirectories="../../../../extlib/smile/;&quot;../../../../extlib/gengetopt-2.22/gl/&quot;;../../../src/;&quot;../../../../extlib/pthreads-w32-2-8-0-release/&quot;"
+				PreprocessorDefinitions="PTW32_STATIC_LIB;NDEBUG;_SECURE_SCL=0"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				BufferSecurityCheck="false"
+				EnableEnhancedInstructionSet="2"
+				WarningLevel="3"
+				WarnAsError="true"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="log4cpp.lib pthreads.lib ws2_32.lib"
+				AdditionalLibraryDirectories="&quot;../../../../extlib/proj/vs2008/$(ConfigurationName)&quot;;../../../../extlib/smile/"
+				GenerateDebugInformation="true"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2E5}"
+			>
+			<File
+				RelativePath="..\..\..\tools\SpeciesConnector\cmdline.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\..\..\../extlib\gengetopt-2.22\gl\getopt.c"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\..\..\../extlib\gengetopt-2.22\gl\getopt1.c"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\tools\SpeciesConnector\SpeciesConnector.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\tools\SpeciesConnector\stdafx.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBE1}"
+			>
+			<File
+				RelativePath="..\..\..\tools\SpeciesConnector\stdafx.h"
+				>
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\..\..\tools\SpeciesConnector\SpeciesConnector.ggo"
+			>
+			<FileConfiguration
+				Name="Debug|Win32"
+				>
+				<Tool
+					Name="GenGetOpts"
+					UnnamedInputs="true"
+				/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Release|Win32"
+				>
+				<Tool
+					Name="GenGetOpts"
+					UnnamedInputs="true"
+				/>
+			</FileConfiguration>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

tools/Dat2Dab/Dat2Dab.cpp

 
 		for( i = 0; i < Dat.GetGenes( ); ++i )
 			if( ( iterName = mapNames.find( Dat.GetGene( i ) ) ) != mapNames.end( ) ) {
-				if( Dat.GetGene( iterName->second ) ) {
+				if( Dat.GetGene( iterName->second ) != -1 ) {
 					cerr << "Duplicate mapping: " << Dat.GetGene( i ) << " to " <<
 						iterName->second << endl;
 					return 1; }

tools/SpeciesConnector/SpeciesConnector.cpp

+/*****************************************************************************
+* This file is provided under the Creative Commons Attribution 3.0 license.
+*
+* You are free to share, copy, distribute, transmit, or adapt this work
+* PROVIDED THAT you attribute the work to the authors listed below.
+* For more information, please see the following web page:
+* http://creativecommons.org/licenses/by/3.0/
+*
+* This file is a component of the Sleipnir library for functional genomics,
+* authored by:
+* Curtis Huttenhower (chuttenh@princeton.edu)
+* Mark Schroeder
+* Maria D. Chikina
+* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
+*
+* If you use this library, the included executable tools, or any related
+* code in your work, please cite the following publication:
+* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
+* Olga G. Troyanskaya.
+* "The Sleipnir library for computational functional genomics"
+*****************************************************************************/
+#include "stdafx.h"
+#include "cmdline.h"
+
+static const char	c_acDab[]	= ".dab";
+
+struct SSorter {
+	const vector<size_t>&	m_veciSizes;
+
+	SSorter( const vector<size_t>& veciSizes ) : m_veciSizes(veciSizes) { }
+
+	bool operator()( size_t iOne, size_t iTwo ) const {
+
+		return ( m_veciSizes[ iOne ] > m_veciSizes[ iTwo ] ); }
+};
+
+float find_value( size_t iOne, size_t iTwo, const CDat& Dat ) {
+
+	return ( ( ( iOne == -1 ) || ( iTwo == -1 ) ) ? CMeta::GetNaN( ) : Dat.Get( iOne, iTwo ) ); }
+
+size_t sample ( vector<float> flag ){
+	size_t						i;
+	float						UnifSamp;
+		
+	UnifSamp = ( float )rand( ) / RAND_MAX; 
+	for( i = 0; i < flag.size( ); ++i ){
+		if( UnifSamp <= flag[ i ] )
+			break;}
+
+	return i;}
+
+int main( int iArgs, char** aszArgs ) {
+	size_t						NGibbs, burn;
+	gengetopt_args_info			sArgs;
+	CDataPair					DatOne, DatTwo;
+	size_t						i, j, k, iDatOne, iDatTwo, iGeneOne, iGeneTwo, count1, count2;
+	size_t						iCountJoint, iValueOne, iValueTwo;
+	vector<size_t>				veciGenesOne, veciGenesTwo, veciDefaults, veciSizes;
+	vector<vector<size_t> >		vecveciJoint;
+	vector<string>				vecstrTInputs, vecstrInputs, vecstrxInputs, vecstrlInputs, vecstrlxInputs, vecstrGenes;
+	float						dValueOne, dValueTwo;
+	map<string, size_t>			mapZeros;
+	CBayesNetSmile				BNIn;
+				
+	if( cmdline_parser( iArgs, aszArgs, &sArgs ) ) {
+		cmdline_parser_print_help( );
+		return 1; }
+	CMeta Meta( sArgs.verbosity_arg, sArgs.random_arg );
+
+	if( sArgs.inputs_num%2 !=0 ){
+		cerr << "Number of inputs should be even." <<  endl;
+		return 1;}
+	
+	NGibbs = burn = sArgs.gibbs_arg;
+
+	vecstrTInputs.resize( sArgs.inputs_num );
+	copy( sArgs.inputs, sArgs.inputs + sArgs.inputs_num, vecstrTInputs.begin( ) );
+
+	vecstrInputs.resize( sArgs.inputs_num/2 );
+	vecstrxInputs.resize( sArgs.inputs_num/2 );
+	vecstrlInputs.resize( sArgs.inputs_num/2 );
+	vecstrlxInputs.resize( sArgs.inputs_num/2 );
+	
+	for( count1 = count2 = 0, i = 0; i < vecstrTInputs.size( ); ++i ){
+		if( strcmp( &vecstrTInputs[ i ][ vecstrTInputs[ i ].rfind( "." ) + 1 ] , "dab" ) == 0 ){
+			vecstrInputs[ count1 ] = vecstrTInputs[ i ];
+			vecstrlInputs[ count1 ].resize( vecstrTInputs[ i ].rfind( "." ) - vecstrTInputs[ i ].rfind( "/" ) - 1 );
+			vecstrlInputs[ count1 ] = vecstrTInputs[ i ].substr( vecstrTInputs[ i ].rfind( "/" ) + 1, vecstrTInputs[ i ].rfind( "." ) - vecstrTInputs[ i ].rfind( "/" ) - 1 ); 
+			count1++;}
+		else if( strcmp( &vecstrTInputs[ i ][ vecstrTInputs[ i ].rfind( "." ) + 1 ], "xdsl" ) == 0 ){ 
+			vecstrxInputs[ count2 ] = vecstrTInputs[ i ];
+			vecstrlxInputs[ count2 ].resize( vecstrTInputs[ i ].rfind( "." ) - vecstrTInputs[ i ].rfind( "/" ) - 1 );
+			vecstrlxInputs[ count2 ] = vecstrTInputs[ i ].substr( vecstrTInputs[ i ].rfind( "/" ) + 1, vecstrTInputs[ i ].rfind( "." ) - vecstrTInputs[ i ].rfind( "/" ) - 1 ); 
+			count2++;}
+		else{
+			cerr << "Input file types should be xdsl and dab." <<  endl;
+			return 1;}}
+
+	vector<size_t>				vecIndInputs;
+	vecIndInputs.resize( vecstrlInputs.size( ) );
+	for( i = 0; i < vecstrlInputs.size( ); ++i ){
+		for( j = 0; j < vecstrlxInputs.size( ); ++j ){
+			if( !vecstrlInputs[ i ].compare( vecstrlxInputs[ j ] ) ){
+				vecIndInputs[ i ] = j;
+				break;}}}
+
+	{	vector<size_t>	veciIndices, veciSizes;
+
+		veciSizes.resize( vecstrInputs.size( ) );
+		veciIndices.resize( vecstrInputs.size( ) );
+		for( i = 0; i < vecstrInputs.size( ); ++i ) {
+			CDat		Dat;
+			ifstream	ifsm;
+
+			veciIndices[ i ] = i;
+			ifsm.open( vecstrInputs[ i ].c_str( ) );
+			Dat.OpenGenes( ifsm, true );
+			veciSizes[ i ] = Dat.GetGenes( ); }
+		sort( veciIndices.begin( ), veciIndices.end( ), SSorter( veciSizes ) );
+		CMeta::Permute( vecstrInputs, veciIndices ); }
+	
+	{	CDataset	Data;
+
+		Data.OpenGenes( vecstrInputs );
+
+		vecstrGenes.resize( Data.GetGenes( ) );
+		copy( Data.GetGeneNames( ).begin( ), Data.GetGeneNames( ).end( ), vecstrGenes.begin( ) );}
+
+	veciSizes.resize( vecstrInputs.size( ) );
+	for( i = 0; i < veciSizes.size( ); ++i ) {
+		DatOne.OpenQuants( vecstrInputs[ i ].c_str( ) );
+		veciSizes[ i ] = DatOne.GetValues( );}
+
+	if( sArgs.zeros_arg ) {
+		ifstream		ifsm;
+		vector<string>	vecstrZeros;
+		char			acLine[ 1024 ];
+
+		ifsm.open( sArgs.zeros_arg );
+		if( !ifsm.is_open( ) ) {
+			cerr << "Could not open: " << sArgs.zeros_arg << endl;
+			return 1; }
+		while( !ifsm.eof( ) ) {
+			ifsm.getline( acLine, ARRAYSIZE(acLine) - 1 );
+			acLine[ ARRAYSIZE(acLine) - 1 ] = 0;
+			vecstrZeros.clear( );
+			CMeta::Tokenize( acLine, vecstrZeros );
+			if( vecstrZeros.empty( ) )
+				continue;
+			mapZeros[ vecstrZeros[ 0 ] ] = atoi( vecstrZeros[ 1 ].c_str( ) ); } }
+
+	vector<vector<float>>					vecPrior;
+	vector<vector<vector<float>>>			vecDataGSpZero;
+	vector<vector<vector<float>>>			vecDataGSpOne;
+	vector<vector<string>>					vecvecSpDat;
+	CDataMatrix		MatCPT;
+	vector<string>	vecstrFiles;
+
+	vecPrior.resize( sArgs.inputs_num/2 );
+	vecDataGSpZero.resize( sArgs.inputs_num/2 );
+	vecDataGSpOne.resize( sArgs.inputs_num/2 );
+	vecvecSpDat.resize( sArgs.inputs_num/2 );
+	for( i = 0; i < vecPrior.size(  ); ++i ){
+		if( !BNIn.Open( vecstrxInputs[ vecIndInputs[ i ] ].c_str( ) ) ) {
+			cerr << "Couldn't open: " << endl;
+			return 1;}
+		BNIn.GetCPT( 0, MatCPT );
+		vecPrior[ i ].resize( MatCPT.GetRows( ) );
+		vecPrior[ i ][ 0 ] = MatCPT.Get( 0, 0 );
+		vecPrior[ i ][ 1 ] = MatCPT.Get( 1, 0 );
+
+		BNIn.GetNodes( vecstrFiles );
+		vecstrFiles.erase( vecstrFiles.begin( ) );
+		vecDataGSpZero[ i ].resize( vecstrFiles.size( ) );
+		vecDataGSpOne[ i ].resize( vecstrFiles.size( ) );
+		vecvecSpDat[ i ].resize( vecstrFiles.size( ) );
+		for( j = 0; j < vecstrFiles.size( ); ++j ){
+			vecvecSpDat[ i ][ j ] = vecstrFiles[ j ];
+			BNIn.GetCPT( j+1, MatCPT );
+			vecDataGSpZero[ i ][ j ].resize( MatCPT.GetRows( ) );
+			vecDataGSpOne[ i ][ j ].resize( MatCPT.GetRows( ) );
+			for( k = 0; k < MatCPT.GetRows( ); ++k ){
+				vecDataGSpZero[ i ][ j ][ k ] = MatCPT.Get( k , 0 );
+				vecDataGSpOne[ i ][ j ][ k ] = MatCPT.Get( k , 1 );}}
+		vecstrFiles.clear( );}
+
+	vector<vector<vector<vector<float>>>>		vec4OSpGSp;
+	vec4OSpGSp.resize( sArgs.inputs_num/2 );
+
+	for( iDatOne = 0; iDatOne < vecstrInputs.size( ); ++iDatOne ) {
+			vec4OSpGSp[ iDatOne ].resize( sArgs.inputs_num/2 );
+			for( iDatTwo = ( iDatOne + 1 ); iDatTwo < vecstrInputs.size( ); ++iDatTwo ) {
+				vec4OSpGSp[ iDatOne ][ iDatTwo ].resize( veciSizes[ iDatOne ] );
+				for( i = 0; i < veciSizes[ iDatOne ]; ++i )
+					vec4OSpGSp[ iDatOne ][ iDatTwo ][ i ].resize( veciSizes[ iDatTwo ] );}}
+	
+	for( iDatOne = 0; iDatOne < vecstrInputs.size( ); ++iDatOne ) {
+			vec4OSpGSp[ iDatOne ].resize( sArgs.inputs_num/2 );
+			for( iDatTwo = 0; iDatTwo < iDatOne; ++iDatTwo ) {
+				vec4OSpGSp[ iDatOne ][ iDatTwo ].resize( veciSizes[ iDatOne ] );
+				for( i = 0; i < veciSizes[ iDatOne ]; ++i )
+					vec4OSpGSp[ iDatOne ][ iDatTwo ][ i ].resize( veciSizes[ iDatTwo ] );}}
+	
+	vector<float>		veciValueOnep;
+	vector<float>		veciValueTwop;
+	
+	for( iDatOne = 0; iDatOne < vecstrInputs.size( ); ++iDatOne ) {
+			if( !( DatOne.Open( vecstrInputs[ iDatOne ].c_str( ), false, !!sArgs.memmap_flag ) ||
+				DatOne.Open( vecstrInputs[ iDatOne ].c_str( ), true, !!sArgs.memmap_flag ) ) ) {
+					cerr << "Could not open: " << vecstrInputs[ iDatOne ] << endl;
+					return 1; }
+
+			if( sArgs.genex_arg && !DatOne.FilterGenes( sArgs.genex_arg, CDat::EFilterExclude ) ){
+				cerr << "Couldn't open: " << sArgs.genex_arg << endl;
+				return 1; }
+
+			veciGenesOne.resize( vecstrGenes.size( ) );
+			for( i = 0; i < vecstrGenes.size( ); ++i )
+				veciGenesOne[ i ] = DatOne.GetGene( vecstrGenes[ i ] );
+
+			if( ( iDatOne + 1 ) == vecstrInputs.size( ) )
+				break;
+
+			for( iDatTwo = ( iDatOne + 1 ); iDatTwo < vecstrInputs.size( ); ++iDatTwo ) {
+				if( !( DatTwo.Open( vecstrInputs[ iDatTwo ].c_str( ), false, !!sArgs.memmap_flag ) ||
+					DatTwo.Open( vecstrInputs[ iDatTwo ].c_str( ), true, !!sArgs.memmap_flag ) ) ) {
+						cerr << "Could not open: " << vecstrInputs[ iDatTwo ] << endl;
+						return 1; }
+
+				if( sArgs.genex_arg && !DatTwo.FilterGenes( sArgs.genex_arg, CDat::EFilterExclude ) ){
+					cerr << "Couldn't open: " << sArgs.genex_arg << endl;
+					return 1; }
+
+				veciGenesTwo.resize( vecstrGenes.size( ) );
+				for( i = 0; i < veciGenesTwo.size( ); ++i )
+					veciGenesTwo[ i ] = DatTwo.GetGene( vecstrGenes[ i ] );
+				
+				vecveciJoint.resize( veciSizes[ iDatOne ] );
+				for( i = 0; i < vecveciJoint.size( ); ++i ) {
+					vecveciJoint[ i ].resize( veciSizes[ iDatTwo ] );
+					fill( vecveciJoint[ i ].begin( ), vecveciJoint[ i ].end( ), 0 ); }
+				
+				for( i = iCountJoint = 0; i < vecstrGenes.size( ); ++i ) {
+					iGeneOne = veciGenesOne[ i ];
+					iGeneTwo = veciGenesTwo[ i ];
+					for( j = ( i + 1 ); j < vecstrGenes.size( ); ++j ) {
+						dValueTwo = find_value( iGeneTwo, veciGenesTwo[ j ], DatTwo );
+						dValueOne = find_value( iGeneOne, veciGenesOne[ j ], DatOne );
+						if( ( !CMeta::IsNaN( dValueTwo = find_value( iGeneTwo, veciGenesTwo[ j ], DatTwo ) ) ) && 
+							( !CMeta::IsNaN( dValueOne = find_value( iGeneOne, veciGenesOne[ j ], DatOne ) ) ) ){
+								iValueTwo = DatTwo.Quantize( dValueTwo );
+								iValueOne = DatOne.Quantize( dValueOne );
+								iCountJoint++;
+								vecveciJoint[ iValueOne ][ iValueTwo ]++;}}}
+
+				size_t				Flag716 = 0;
+				for( i = 0; i < vecveciJoint.size( ); ++i )
+					for( j = 0; j < vecveciJoint[ i ].size( ); ++j )
+						Flag716 += vecveciJoint[ i ][ j ];
+
+				if( Flag716 < 10 ){
+					cerr << "Total number of common edges between the answer files of " << vecstrlInputs[ iDatOne ].c_str( ) << " and " 
+						<< vecstrlInputs[ iDatTwo ].c_str( ) << " should be much greater than 10" << endl;
+					return 1;}
+
+				Flag716 = Flag716/10;
+
+				for( i = 0; i < vecveciJoint.size( ); ++i ){
+					for( j = 0; j < vecveciJoint[ i ].size( ); ++j ){
+						vecveciJoint[ i ][ j ] += Flag716;
+						iCountJoint += Flag716;}}
+
+				vector<vector<float> >		vecveciTJoint;
+				vecveciTJoint.resize( vecveciJoint.size( ) );
+				for( i = 0; i < vecveciTJoint.size( ); ++i ){
+					vecveciTJoint[ i ].resize( vecveciJoint[ i ].size( ) );
+					for( j = 0; j < vecveciTJoint.size( ); ++j ){ 
+						vecveciTJoint[ i ][ j ] = (float)vecveciJoint[ i ][ j ] / iCountJoint;}}				
+									 							
+				veciValueOnep.resize( veciSizes[ iDatOne ] );
+				veciValueTwop.resize( veciSizes[ iDatTwo ] );
+				fill( veciValueOnep.begin( ), veciValueOnep.end( ), 0.0f );
+				fill( veciValueTwop.begin( ), veciValueTwop.end( ), 0.0f );
+				
+				for( i = 0; i < vecveciJoint.size( ); ++i ){
+					for( j = 0; j < vecveciJoint[ i ].size( ); ++j ){
+						veciValueOnep[ i ] += vecveciTJoint[ i ][ j ];
+						veciValueTwop[ j ] += vecveciTJoint[ i ][ j ];}} 
+
+				for( i = 0; i < vecveciJoint.size( ); ++i ){
+					for( j = 0; j < vecveciJoint[ i ].size(  ); ++j ){
+						vec4OSpGSp[ iDatOne ][ iDatTwo ][ i ][ j ] = vecveciTJoint[ i ][ j ] / veciValueOnep[ i ];
+						vec4OSpGSp[ iDatTwo ][ iDatOne ][ i ][ j ] = vecveciTJoint[ j ][ i ] / veciValueTwop[ i ];}}}}
+
+	// Gibbs Magic
+	vector<float>				vecMax;
+	vecMax.resize( sArgs.inputs_num/2 );
+	for( i = 0; i < vecMax.size( ); ++i ){
+		float Max = 0;
+		for( j = 0; j < vecDataGSpZero[ i ].size(  ); ++j ){
+			float		temp1;
+			float		temp2;
+			temp1 = *max_element( vecDataGSpZero[ i ][ j ].begin( ), vecDataGSpZero[ i ][ j ].end( ) );
+			temp2 = *max_element( vecDataGSpOne[ i ][ j ].begin( ), vecDataGSpOne[ i ][ j ].end( ) );
+			Max += ( temp1 >= temp2 ) ? log ( temp1 ) : log( temp2 );}
+				
+		for( j = 0; j < sArgs.inputs_num/2; ++j ){
+			if( j != i ){
+				vector<float>	temp3;
+				temp3.resize( vec4OSpGSp[ i ][ j ].size( ) );
+				for( k = 0; k < vec4OSpGSp[ i ][ j ].size( ) ; ++k )
+					temp3[ k ] = *max_element( vec4OSpGSp[ i ][ j ][ k ].begin( ), vec4OSpGSp[ i ][ j ][ k ].end( ) );
+				Max += log ( *max_element( temp3.begin( ), temp3.end( ) ) );}}
+		vecMax[ i ] = Max;}
+
+	// Initialization
+	vector<size_t>					vecTSamples;
+	vecTSamples.resize( sArgs.inputs_num/2 );
+	for( i = 0; i < vecTSamples.size( ); ++i  ){
+		vector<float>			temp4;
+		temp4.resize( vecPrior[ i ].size( ) );
+		temp4[ 0 ] = vecPrior[ i ][ 0 ];
+		for( j = 1; j < vecPrior[ i ].size( ); ++j )
+			temp4[ j ] = temp4[ j - 1 ] + vecPrior[ i ][ j ];
+
+		vecTSamples[ i ] = sample( temp4 );}
+	
+	// Sampling
+	CDat		DatOut00, DatOut01, DatOut10; 
+	DatOut00.Open( vecstrlInputs );
+	DatOut01.Open( vecstrlInputs );
+	DatOut10.Open( vecstrlInputs );
+	
+	for( i = 0; i < NGibbs; ++i ){ 
+		vector<vector<size_t>>		vecvecDSp;
+		vecvecDSp.resize( sArgs.inputs_num/2 );
+		for( j = 0; j < sArgs.inputs_num/2; ++j ){
+//			const vector<float>&	vecdCur	= ( vecTSamples[j] ? vecDataGSpOne : vecDataGSpZero );
+
+			vecvecDSp[ j ].resize( vecDataGSpZero[ j ].size(  ) );
+			if( !vecTSamples[ j ] ){
+				for( k = 0; k < vecDataGSpZero[ j ].size( ); ++k ){
+					vector<float>		temp5;
+					size_t				l;
+					temp5.resize( vecDataGSpZero[ j ][ k ].size( ) );
+					temp5[ 0 ] = vecDataGSpZero[ j ][ k ][ 0 ];
+					for( l = 1; l < vecDataGSpZero[ j ][ k ].size( ); ++l )
+						temp5[ l ] = temp5[ l - 1 ] + vecDataGSpZero[ j ][ k ][ l ];
+					vecvecDSp[ j ][ k ] = sample( temp5 );}}
+			else{
+				for( k = 0; k < vecDataGSpOne[ j ].size(  ); ++k ){
+					vector<float>		temp5;
+					size_t				l;
+					temp5.resize( vecDataGSpOne[ j ][ k ].size( ) );
+					temp5[ 0 ] = vecDataGSpOne[ j ][ k ][ 0 ];
+					for( l = 1; l < vecDataGSpOne[ j ][ k ].size( ); ++l )
+						temp5[ l ] = temp5[ l - 1 ] + vecDataGSpOne[ j ][ k ][ l ];
+					vecvecDSp[ j ][ k ] = sample( temp5 );}}
+
+			vector<float>			temp6;
+			temp6.resize( vecPrior[ j ].size( ) );
+			temp6[ 0 ] = vecPrior[ j ][ 0 ];
+			for( k = 1; k < vecPrior[ j ].size( ); ++k )
+				temp6[ k ] = temp6[ k - 1 ] + vecPrior[ j ][ k ];
+			
+			float		sum;
+			do{ 
+				vecTSamples[ j ] = sample( temp6 );
+				sum = 0;
+				for( k = 0; k < vecvecDSp[ j ].size( ); ++k ){
+// same fix here for multi vectors
+					if( !vecTSamples[ j ] )
+						sum += log ( vecDataGSpZero[ j ][ k ][ vecvecDSp[ j ][ k ] ] );
+					else
+						sum += log ( vecDataGSpOne[ j ][ k ][ vecvecDSp[ j ][ k ] ] );}
+
+				for( k = 0; k < sArgs.inputs_num/2; ++k )
+					if( k != j )
+						sum += log ( vec4OSpGSp[ j ][ k ][ vecTSamples[ j ] ][ vecTSamples[ k ] ] );
+			} while ( log ( (float)rand( ) / RAND_MAX ) > ( sum - vecMax[ j ] ) );
+		}
+		 
+		if( i >= ( NGibbs - burn ) ){
+			for( j = 0; j < sArgs.inputs_num/2; ++j ){
+				for( k = j+1; k < sArgs.inputs_num/2; ++k ){
+					if( !vecTSamples[ j ] && !vecTSamples[ k ] ){
+						if( CMeta::IsNaN( DatOut00.Get( j, k ) ) )
+							DatOut00.Set( j, k, 1 );
+						else
+							DatOut00.Set( j, k, ++DatOut00.Get( j, k ) );}
+					if( !vecTSamples[ j ] && vecTSamples[ k ] ){
+						if( CMeta::IsNaN( DatOut01.Get( j, k ) ) )
+							DatOut01.Set( j, k, 1 );
+						else 
+							DatOut01.Set( j, k, ++DatOut01.Get( j, k ) );}
+					if( vecTSamples[ j ] && !vecTSamples[ k ] ){
+						if( CMeta::IsNaN( DatOut10.Get( j, k ) ) )
+							DatOut10.Set( j, k, 1 );
+						else
+							DatOut10.Set( j, k, ++DatOut10.Get( j, k ) );}}}}	
+	}
+	
+	_mkdir( sArgs.directory_arg );
+	
+	vector<vector<vector<vector<float>>>>		vec4FSpGSp;
+	vec4FSpGSp.resize( sArgs.inputs_num/2 );
+	
+	for( iDatOne = 0; iDatOne < vecstrInputs.size( ); ++iDatOne ) {
+			vec4FSpGSp[ iDatOne ].resize( sArgs.inputs_num/2 );
+			for( iDatTwo = ( iDatOne + 1 ); iDatTwo < vecstrInputs.size( ); ++iDatTwo ) {
+				vec4FSpGSp[ iDatOne ][ iDatTwo ].resize( veciSizes[ iDatOne ] );
+				for( i = 0; i < veciSizes[ iDatOne ]; ++i )
+					vec4FSpGSp[ iDatOne ][ iDatTwo ][ i ].resize( veciSizes[ iDatTwo ] );}}
+
+	for( j = 0; j < sArgs.inputs_num/2; ++j ){
+		for( k = j+1; k < sArgs.inputs_num/2; ++k ){
+			double			DJValue;
+			if( !CMeta::IsNaN( DatOut00.Get( j, k ) ) ){
+				DJValue = DatOut00.Get( j, k );
+				DatOut00.Set( j, k, ( (float) DJValue / burn ) );
+				vec4FSpGSp[ j ][ k ][ 0 ][ 0 ] = DatOut00.Get( j, k );}
+			if( !CMeta::IsNaN( DatOut01.Get( j, k ) ) ){
+				DJValue = DatOut01.Get( j, k );
+				DatOut01.Set( j, k, ( (float) DJValue / burn ) );
+				vec4FSpGSp[ j ][ k ][ 0 ][ 1 ] = DatOut01.Get( j, k );}
+			if( !CMeta::IsNaN( DatOut10.Get( j, k ) ) ){
+				DJValue = DatOut10.Get( j, k );
+				DatOut10.Set( j, k, ( (float) DJValue / burn ) );
+				vec4FSpGSp[ j ][ k ][ 1 ][ 0 ] = DatOut10.Get( j, k );}
+
+			float		First3Sum = vec4FSpGSp[ j ][ k ][ 0 ][ 0 ] + vec4FSpGSp[ j ][ k ][ 0 ][ 1 ] + vec4FSpGSp[ j ][ k ][ 1 ][ 0 ];
+
+			vec4FSpGSp[ j ][ k ][ 1 ][ 1 ] = ( First3Sum == 1 ) ? 0.0f : ( 1.0f - First3Sum );}}
+	
+	DatOut00.Save( ( ( string ) sArgs.directory_arg + "/Learned00.dab" ).c_str( ) );
+	DatOut01.Save( ( ( string ) sArgs.directory_arg + "/Learned01.dab" ).c_str( ) );
+	DatOut10.Save( ( ( string ) sArgs.directory_arg + "/Learned10.dab" ).c_str( ) );
+	
+    for( iDatOne = 0; iDatOne < vecstrInputs.size( ); ++iDatOne ) {
+        vec4FSpGSp[ iDatOne ].resize( sArgs.inputs_num/2 );
+        for( iDatTwo = 0; iDatTwo < iDatOne; ++iDatTwo ) {
+            vec4FSpGSp[ iDatOne ][ iDatTwo ].resize( veciSizes[ iDatOne ] );
+            for( i = 0; i < veciSizes[ iDatOne ]; ++i )
+                vec4FSpGSp[ iDatOne ][ iDatTwo ][ i ].resize( veciSizes[ iDatTwo ] );}}
+
+    for( iDatOne = 0; iDatOne < vec4FSpGSp.size( ); ++iDatOne ) {
+        for( iDatTwo = ( iDatOne + 1 ); iDatTwo < vec4FSpGSp[ iDatOne ].size( ); ++iDatTwo ) {
+            vector<vector<float>>			vecvecFTJoint;
+            float							MaxFJoint = 0;
+            size_t							ZeroFCount = 0;
+            vecvecFTJoint.resize( vec4FSpGSp[ iDatOne ][ iDatTwo ].size( ) );
+            for( j = 0; j < vec4FSpGSp[ iDatOne ][ iDatTwo ].size( ); ++j ){
+                vecvecFTJoint[ j ].resize( vec4FSpGSp[ iDatOne ][ iDatTwo ][ j ].size( ) );
+                fill( vecvecFTJoint[ j ].begin( ), vecvecFTJoint[ j ].end( ), 0.0f );
+                for( k = 0; k < vec4FSpGSp[ iDatOne ][ iDatTwo ][ j ].size( ); ++k ){
+                    vecvecFTJoint[ j ][ k ] = vec4FSpGSp[ iDatOne ][ iDatTwo ][ j ][ k ];
+                    if( !vecvecFTJoint[ j ][ k ] )
+                        ZeroFCount++;
+                    if( vecvecFTJoint[ j ][ k ] > MaxFJoint )
+                        MaxFJoint = vecvecFTJoint[ j ][ k ];}}
+
+            if( ZeroFCount ){
+                float							BiasF;
+                size_t							BiasFFlag = 0;
+
+                BiasF = ( float ) MaxFJoint / ZeroFCount / veciSizes[ iDatTwo ] / veciSizes[ iDatOne ] / 100;
+
+                for( i = 0; i < vecvecFTJoint.size( ); ++i )
+                    for( j = 0; j < vecvecFTJoint[ i ].size( ); ++j )
+                        if( !vecvecFTJoint[ i ][ j ] )
+                            vecvecFTJoint[ i ][ j ] = BiasF;
+
+                for( i = 0; i < vecvecFTJoint.size( ); ++i ){
+                    for( j = 0; j < vecvecFTJoint[ i ].size( ); ++j ){
+                        if( !( vecvecFTJoint[ i ][ j ] - MaxFJoint ) ){
+                            vecvecFTJoint[ i ][ j ] -= ( BiasF * ZeroFCount );
+                            BiasFFlag = 1;
+                            break;}}
+                    if( BiasFFlag )
+                        break;}}
+        
+            vector<float>		vecFValueOnep;
+            vector<float>		vecFValueTwop;
+
+            vecFValueOnep.resize( veciSizes[ iDatOne ] );
+            vecFValueTwop.resize( veciSizes[ iDatTwo ] );
+            fill( vecFValueOnep.begin( ), vecFValueOnep.end( ), 0.0f );
+            fill( vecFValueTwop.begin( ), vecFValueTwop.end( ), 0.0f );
+
+            for( i = 0; i < vecvecFTJoint.size( ); ++i ){
+                for( j = 0; j < vecvecFTJoint[ i ].size( ); ++j ){
+                    vecFValueOnep[ i ] += vecvecFTJoint[ i ][ j ];
+                    vecFValueTwop[ j ] += vecvecFTJoint[ i ][ j ];}} 
+
+            for( i = 0; i < vecvecFTJoint.size( ); ++i ){
+                for( j = 0; j < vecvecFTJoint[ i ].size(  ); ++j ){
+                    vec4FSpGSp[ iDatOne ][ iDatTwo ][ i ][ j ] = vecvecFTJoint[ i ][ j ] / vecFValueOnep[ i ];
+                    vec4FSpGSp[ iDatTwo ][ iDatOne ][ i ][ j ] = vecvecFTJoint[ j ][ i ] / vecFValueTwop[ i ];}}}}
+    
+    vector<vector<string>>		vecvecstrInputs;
+    size_t						countstrInputs;
+    vecvecstrInputs.resize( vecvecSpDat.size( ) );
+    countstrInputs = 0;
+    for( i = 0; i < vecvecSpDat.size( ); ++i ){
+        vecvecstrInputs[ i ].resize( vecvecSpDat[ i ].size( ) ); 
+        for( j = 0; j < vecvecSpDat[ i ].size( ); ++j ){
+            vecvecstrInputs[ i ][ j ] =  ( string )sArgs.ndirectory_arg + '/' + vecstrlInputs[ i ] + '/' + vecvecSpDat[ i ][ j ] + c_acDab;
+            countstrInputs++;}}
+
+    vector<string>				vecstrFInputs;
+    vector<vector<size_t>>		InputMaps;				
+    vecstrFInputs.resize( countstrInputs );
+    countstrInputs = 0;
+    InputMaps.resize( vecvecstrInputs.size( ) );
+    for( i = 0; i < vecvecstrInputs.size( ); ++i ){
+        InputMaps[ i ].resize( vecvecstrInputs[ i ].size( ) );
+        for( j = 0; j < vecvecstrInputs[ i ].size( ); ++j ){
+            vecstrFInputs[ countstrInputs ] = vecvecstrInputs[ i ][ j ].c_str( );
+            InputMaps[ i ][ j ] = countstrInputs;
+            countstrInputs++;}}
+    
+    vector<string>		vecstrFGenes;
+    
+    {	CDataset	DataF;
+
+        DataF.OpenGenes( vecstrFInputs );
+        vecstrFGenes.resize( DataF.GetGenes( ) );
+        copy( DataF.GetGeneNames( ).begin( ), DataF.GetGeneNames( ).end( ), vecstrFGenes.begin( ) );}
+
+    vector<CDataPair*>			DataF;
+    size_t						iDatOneF, iDatTwoF, iGeneOneF, iGeneTwoF;
+    
+    DataF.resize( vecstrFInputs.size( ) );
+    for( i = 0; i < vecstrFInputs.size( ); ++i ){
+        DataF[ i ] = new CDataPair( );
+        if( !( DataF[ i ]->Open( vecstrFInputs[ i ].c_str( ), false, !!sArgs.memmap_flag ) ||
+            DataF[ i ]->Open( vecstrFInputs[ i ].c_str( ), true, !!sArgs.memmap_flag ) ) ){
+                cerr << "Could not open:" << vecstrFInputs[ i ] << endl;
+                return 1;}}
+        
+    vector<CDat*>			DatOutCS, DatOutCSH, DatOutB;	
+
+    DatOutCS.resize( vecvecstrInputs.size( ) );
+    for( i = 0; i < DatOutCS.size( ); ++i ){
+        DatOutCS[ i ] = new CDat( );
+        DatOutCS[ i ]->Open( vecstrFGenes );}
+
+    DatOutCSH.resize( vecvecstrInputs.size( ) );
+    for( i = 0; i < DatOutCSH.size( ); ++i ){
+        DatOutCSH[ i ] = new CDat( );
+        DatOutCSH[ i ]->Open( vecstrFGenes );}
+
+	DatOutB.resize( vecvecstrInputs.size( ) );
+    for( i = 0; i < DatOutB.size( ); ++i ){
+        DatOutB[ i ] = new CDat( );
+        DatOutB[ i ]->Open( vecstrFGenes );}
+
+    vector<vector<vector<size_t>>>		vec3GeneIndex;
+    vec3GeneIndex.resize( vecvecstrInputs.size( ) );
+    for( i = 0; i < vecvecstrInputs.size( ); ++i ){
+        vec3GeneIndex[ i ].resize( vecvecstrInputs[ i ].size( ) );
+        for( j = 0; j < vecvecstrInputs[ i ].size( ); ++j ){
+            vec3GeneIndex[ i ][ j ].resize( vecstrFGenes.size( ) );
+            for( k = 0; k < vecstrFGenes.size( ); ++k ){
+                vec3GeneIndex[ i ][ j ][ k ] = DataF[ InputMaps[ i ][ j ] ]->GetGene( vecstrFGenes[ k ] );}}}
+            
+    for( iDatOneF = 0; iDatOneF < vecstrFGenes.size( ); ++iDatOneF ){ 
+        for( iDatTwoF = ( iDatOneF + 1 ); iDatTwoF < vecstrFGenes.size( ); ++iDatTwoF ){ 
+            vector<float>		vecDataIntZero;
+            vector<float>		vecDataIntOne;
+            vecDataIntZero.resize( vecvecstrInputs.size( ) );
+            fill( vecDataIntZero.begin( ), vecDataIntZero.end( ), 0.0f );
+            vecDataIntOne.resize( vecvecstrInputs.size( ) );
+            fill( vecDataIntOne.begin( ), vecDataIntOne.end( ), 0.0f );
+            for( i = 0; i < vecvecstrInputs.size( ); ++i ){
+                float		sumZero = 0;
+                float		sumOne = 0;
+                for( j = 0; j < vecvecstrInputs[ i ].size( ); ++j ){
+                    iGeneOneF = vec3GeneIndex[ i ][ j ][ iDatOneF ];
+                    iGeneTwoF = vec3GeneIndex[ i ][ j ][ iDatTwoF ];
+                    float		DFValue;
+                    DFValue = ( ( iGeneOneF == -1 ) || ( iGeneTwoF == -1 ) ) ? CMeta::GetNaN( ) : DataF[ InputMaps[ i ][ j ] ]->Get( iGeneOneF, iGeneTwoF );
+                    if( !CMeta::IsNaN( DFValue ) ){
+                        size_t		DatPFI = DataF[ InputMaps[ i ][ j ] ]->Quantize( DFValue );
+                        sumZero += log( vecDataGSpZero[ i ][ j ][ DatPFI ] );
+                        sumOne += log( vecDataGSpOne[ i ][ j ][ DatPFI ] );}}
+                vecDataIntZero[ i ] = sumZero;
+                vecDataIntOne[ i ] = sumOne;}
+
+            for( i = 0; i < vecvecstrInputs.size( ); ++i ){
+                float		sumOne = 0, sumZero = 0, Final = 0 ;
+				float		sumOneB = 0, sumZeroB = 0, FinalB = 0 ;
+				float		sumOneT = 0, sumZeroT = 0, FinalT = 0;
+                for( k = 0; k < vecvecstrInputs.size( ); ++k ){
+                    if( k != i ){
+                        sumOne += log( exp( log( vec4FSpGSp[ i ][ k ][ 1 ][ 0 ] ) + vecDataIntZero[ k ] ) + exp( log( vec4FSpGSp[ i ][ k ][ 1 ][ 1 ] ) + vecDataIntOne[ k ] ) );
+                        sumZero += log( exp( log( vec4FSpGSp[ i ][ k ][ 0 ][ 0 ] ) + vecDataIntZero[ k ] ) + exp( log( vec4FSpGSp[ i ][ k ][ 0 ][ 1 ] ) + vecDataIntOne[ k ] ) );}}
+                sumOneT = sumOne + log( vecPrior[ i ][ 1 ] );
+				sumOne += ( vecDataIntOne[ i ] + log( vecPrior[ i ][ 1 ] ) );
+				sumOneB =  vecDataIntOne[ i ] + log( vecPrior[ i ][ 1 ] );
+                sumZeroT = sumZero + log( vecPrior[ i ][ 0 ] );
+				sumZero += ( vecDataIntZero[ i ] + log( vecPrior[ i ][ 0 ] ) );
+				sumZeroB =  vecDataIntZero[ i ] + log( vecPrior[ i ][ 0 ] );
+                Final = (float) ( 1 / ( 1 + exp ( sumZero - sumOne ) ) );
+				FinalT = (float) ( 1 / ( 1 + exp ( sumZeroT - sumOneT ) ) );
+				FinalB = (float) ( 1 / ( 1 + exp ( sumZeroB - sumOneB ) ) );
+				DatOutCS[ i ]->Set( iDatOneF, iDatTwoF, Final );
+				DatOutCSH[ i ]->Set( iDatOneF, iDatTwoF, FinalT );
+				DatOutB[ i ]->Set( iDatOneF, iDatTwoF, FinalB );}}}
+                
+    for( i = 0; i < vecvecstrInputs.size( ); ++i ){
+        DatOutCS[ i ]->Save( ( ( string ) sArgs.directory_arg + '/' + vecstrlInputs[ i ] + c_acDab ).c_str( ) );
+		DatOutCSH[ i ]->Save( ( ( string ) sArgs.directory_arg + '/' + vecstrlInputs[ i ] + 'h' + c_acDab ).c_str( ) );
+		DatOutB[ i ]->Save( ( ( string ) sArgs.directory_arg + '/' + vecstrlInputs[ i ] + 'b' + c_acDab ).c_str( ) );
+        delete DataF[ i ];
+    delete DatOutCS[ i ];
+	delete DatOutCSH[ i ];
+	delete DatOutB[ i ];}	
+	
+	return 0;}

tools/SpeciesConnector/SpeciesConnector.ggo

+package	"SpeciesConnector"
+version	"1.0"
+purpose	"Cross species connection calculator."
+
+section "Main"
+option	"ndirectory" n	"Input directory"
+						string	typestr="directory"	default="."
+option	"directory"	d	"Output directory"
+						string	typestr="directory"	default="."
+option	"gibbs"		g	"Gibbs run"
+						int	default="100000"
+
+section "Network Features"
+option	"zero"		z	"Zero missing values"
+						flag	off
+option	"zeros"		Z	"Read zeroed node IDs/outputs from the given file"
+						string	typestr="filename"
+
+section "Optional"
+option	"genex"		G	"Gene exclusion file"
+						string	typestr="filename"
+option	"subsample"	s	"Maximum pairs to subsample"
+						int	default="100000"
+option	"memmap"	m	"Memory map input/output"
+						flag	off
+option	"random"	r	"Seed random generator"
+						int	default="0"
+option	"verbosity"	v	"Message verbosity"
+						int	default="5"

tools/SpeciesConnector/cmdline.c

+/*
+  File autogenerated by gengetopt version 2.22
+  generated with the following command:
+  ..\..\..\..\extlib\proj\vs2008\release\gengetopt.exe -u --default-optional -N -e --output-dir=c:\Users\Pinaki Sarder\Documents\Visual Studio 2008\Projects\sleipnir\trunk\tools\SpeciesConnector\ -i ..\..\..\tools\SpeciesConnector\SpeciesConnector.ggo 
+
+  The developers of gengetopt consider the fixed text that goes in all
+  gengetopt output files to be in the public domain:
+  we make no copyright claims on it.
+*/
+
+/* If we use autoconf.  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "getopt.h"
+
+#include "cmdline.h"
+
+const char *gengetopt_args_info_purpose = "Cross species connection calculator.";
+
+const char *gengetopt_args_info_usage = "Usage: SpeciesConnector [OPTIONS]... [FILES]...";
+
+const char *gengetopt_args_info_description = "";
+
+const char *gengetopt_args_info_help[] = {
+  "  -h, --help                  Print help and exit",
+  "  -V, --version               Print version and exit",
+  "\nMain:",
+  "  -n, --ndirectory=directory  Input directory  (default=`.')",
+  "  -d, --directory=directory   Output directory  (default=`.')",
+  "  -g, --gibbs=INT             Gibbs run  (default=`100000')",
+  "\nNetwork Features:",
+  "  -z, --zero                  Zero missing values  (default=off)",
+  "  -Z, --zeros=filename        Read zeroed node IDs/outputs from the given file",
+  "\nOptional:",
+  "  -G, --genex=filename        Gene exclusion file",
+  "  -s, --subsample=INT         Maximum pairs to subsample  (default=`100000')",
+  "  -m, --memmap                Memory map input/output  (default=off)",
+  "  -r, --random=INT            Seed random generator  (default=`0')",
+  "  -v, --verbosity=INT         Message verbosity  (default=`5')",
+    0
+};
+
+typedef enum {ARG_NO
+  , ARG_FLAG
+  , ARG_STRING
+  , ARG_INT
+} cmdline_parser_arg_type;
+
+static
+void clear_given (struct gengetopt_args_info *args_info);
+static
+void clear_args (struct gengetopt_args_info *args_info);
+
+static int
+cmdline_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
+                        struct cmdline_parser_params *params, const char *additional_error);
+
+
+static char *
+gengetopt_strdup (const char *s);
+
+static
+void clear_given (struct gengetopt_args_info *args_info)
+{
+  args_info->help_given = 0 ;
+  args_info->version_given = 0 ;
+  args_info->ndirectory_given = 0 ;
+  args_info->directory_given = 0 ;
+  args_info->gibbs_given = 0 ;
+  args_info->zero_given = 0 ;
+  args_info->zeros_given = 0 ;
+  args_info->genex_given = 0 ;
+  args_info->subsample_given = 0 ;
+  args_info->memmap_given = 0 ;
+  args_info->random_given = 0 ;
+  args_info->verbosity_given = 0 ;
+}
+
+static
+void clear_args (struct gengetopt_args_info *args_info)
+{
+  args_info->ndirectory_arg = gengetopt_strdup (".");
+  args_info->ndirectory_orig = NULL;
+  args_info->directory_arg = gengetopt_strdup (".");
+  args_info->directory_orig = NULL;
+  args_info->gibbs_arg = 100000;
+  args_info->gibbs_orig = NULL;
+  args_info->zero_flag = 0;
+  args_info->zeros_arg = NULL;
+  args_info->zeros_orig = NULL;
+  args_info->genex_arg = NULL;
+  args_info->genex_orig = NULL;
+  args_info->subsample_arg = 100000;
+  args_info->subsample_orig = NULL;
+  args_info->memmap_flag = 0;
+  args_info->random_arg = 0;
+  args_info->random_orig = NULL;
+  args_info->verbosity_arg = 5;
+  args_info->verbosity_orig = NULL;
+  
+}
+
+static
+void init_args_info(struct gengetopt_args_info *args_info)
+{
+
+
+  args_info->help_help = gengetopt_args_info_help[0] ;
+  args_info->version_help = gengetopt_args_info_help[1] ;
+  args_info->ndirectory_help = gengetopt_args_info_help[3] ;
+  args_info->directory_help = gengetopt_args_info_help[4] ;
+  args_info->gibbs_help = gengetopt_args_info_help[5] ;
+  args_info->zero_help = gengetopt_args_info_help[7] ;
+  args_info->zeros_help = gengetopt_args_info_help[8] ;
+  args_info->genex_help = gengetopt_args_info_help[10] ;
+  args_info->subsample_help = gengetopt_args_info_help[11] ;
+  args_info->memmap_help = gengetopt_args_info_help[12] ;
+  args_info->random_help = gengetopt_args_info_help[13] ;
+  args_info->verbosity_help = gengetopt_args_info_help[14] ;
+  
+}
+
+void
+cmdline_parser_print_version (void)
+{
+  printf ("%s %s\n", CMDLINE_PARSER_PACKAGE, CMDLINE_PARSER_VERSION);
+}
+
+static void print_help_common(void) {
+  cmdline_parser_print_version ();
+
+  if (strlen(gengetopt_args_info_purpose) > 0)
+    printf("\n%s\n", gengetopt_args_info_purpose);
+
+  if (strlen(gengetopt_args_info_usage) > 0)
+    printf("\n%s\n", gengetopt_args_info_usage);
+
+  printf("\n");
+
+  if (strlen(gengetopt_args_info_description) > 0)
+    printf("%s\n", gengetopt_args_info_description);
+}
+
+void
+cmdline_parser_print_help (void)
+{
+  int i = 0;
+  print_help_common();
+  while (gengetopt_args_info_help[i])
+    printf("%s\n", gengetopt_args_info_help[i++]);
+}
+
+void
+cmdline_parser_init (struct gengetopt_args_info *args_info)
+{
+  clear_given (args_info);
+  clear_args (args_info);
+  init_args_info (args_info);
+
+  args_info->inputs = NULL;
+  args_info->inputs_num = 0;
+}
+
+void
+cmdline_parser_params_init(struct cmdline_parser_params *params)
+{
+  if (params)
+    { 
+      params->override = 0;
+      params->initialize = 1;
+      params->check_required = 1;
+      params->check_ambiguity = 0;
+      params->print_errors = 1;
+    }
+}
+
+struct cmdline_parser_params *
+cmdline_parser_params_create(void)
+{
+  struct cmdline_parser_params *params = 
+    (struct cmdline_parser_params *)malloc(sizeof(struct cmdline_parser_params));
+  cmdline_parser_params_init(params);  
+  return params;
+}
+
+static void
+free_string_field (char **s)
+{
+  if (*s)
+    {
+      free (*s);
+      *s = 0;
+    }
+}
+
+
+static void
+cmdline_parser_release (struct gengetopt_args_info *args_info)
+{
+  unsigned int i;
+  free_string_field (&(args_info->ndirectory_arg));
+  free_string_field (&(args_info->ndirectory_orig));
+  free_string_field (&(args_info->directory_arg));
+  free_string_field (&(args_info->directory_orig));
+  free_string_field (&(args_info->gibbs_orig));
+  free_string_field (&(args_info->zeros_arg));
+  free_string_field (&(args_info->zeros_orig));
+  free_string_field (&(args_info->genex_arg));
+  free_string_field (&(args_info->genex_orig));
+  free_string_field (&(args_info->subsample_orig));
+  free_string_field (&(args_info->random_orig));
+  free_string_field (&(args_info->verbosity_orig));
+  
+  
+  for (i = 0; i < args_info->inputs_num; ++i)
+    free (args_info->inputs [i]);
+
+  if (args_info->inputs_num)
+    free (args_info->inputs);
+
+  clear_given (args_info);
+}
+
+
+static void
+write_into_file(FILE *outfile, const char *opt, const char *arg, char *values[])
+{
+  if (arg) {
+    fprintf(outfile, "%s=\"%s\"\n", opt, arg);
+  } else {
+    fprintf(outfile, "%s\n", opt);
+  }
+}
+
+
+int
+cmdline_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info)
+{
+  int i = 0;
+
+  if (!outfile)
+    {
+      fprintf (stderr, "%s: cannot dump options to stream\n", CMDLINE_PARSER_PACKAGE);
+      return EXIT_FAILURE;
+    }
+
+  if (args_info->help_given)
+    write_into_file(outfile, "help", 0, 0 );
+  if (args_info->version_given)
+    write_into_file(outfile, "version", 0, 0 );
+  if (args_info->ndirectory_given)
+    write_into_file(outfile, "ndirectory", args_info->ndirectory_orig, 0);
+  if (args_info->directory_given)
+    write_into_file(outfile, "directory", args_info->directory_orig, 0);
+  if (args_info->gibbs_given)
+    write_into_file(outfile, "gibbs", args_info->gibbs_orig, 0);
+  if (args_info->zero_given)
+    write_into_file(outfile, "zero", 0, 0 );
+  if (args_info->zeros_given)
+    write_into_file(outfile, "zeros", args_info->zeros_orig, 0);
+  if (args_info->genex_given)
+    write_into_file(outfile, "genex", args_info->genex_orig, 0);
+  if (args_info->subsample_given)
+    write_into_file(outfile, "subsample", args_info->subsample_orig, 0);
+  if (args_info->memmap_given)
+    write_into_file(outfile, "memmap", 0, 0 );
+  if (args_info->random_given)
+    write_into_file(outfile, "random", args_info->random_orig, 0);
+  if (args_info->verbosity_given)
+    write_into_file(outfile, "verbosity", args_info->verbosity_orig, 0);
+  
+
+  i = EXIT_SUCCESS;
+  return i;
+}
+
+int
+cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
+{
+  FILE *outfile;
+  int i = 0;
+
+  outfile = fopen(filename, "w");
+
+  if (!outfile)
+    {
+      fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename);
+      return EXIT_FAILURE;
+    }
+
+  i = cmdline_parser_dump(outfile, args_info);
+  fclose (outfile);
+
+  return i;
+}
+
+void
+cmdline_parser_free (struct gengetopt_args_info *args_info)
+{
+  cmdline_parser_release (args_info);
+}
+
+/** @brief replacement of strdup, which is not standard */
+char *
+gengetopt_strdup (const char *s)
+{
+  char *result = NULL;
+  if (!s)
+    return result;
+
+  result = (char*)malloc(strlen(s) + 1);
+  if (result == (char*)0)
+    return (char*)0;
+  strcpy(result, s);
+  return result;
+}
+
+int
+cmdline_parser (int argc, char * const *argv, struct gengetopt_args_info *args_info)
+{
+  return cmdline_parser2 (argc, argv, args_info, 0, 1, 1);
+}
+
+int
+cmdline_parser_ext (int argc, char * const *argv, struct gengetopt_args_info *args_info,
+                   struct cmdline_parser_params *params)
+{
+  int result;
+  result = cmdline_parser_internal (argc, argv, args_info, params, NULL);
+
+  return result;
+}
+
+int
+cmdline_parser2 (int argc, char * const *argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required)
+{
+  int result;
+  struct cmdline_parser_params params;
+  
+  params.override = override;
+  params.initialize = initialize;
+  params.check_required = check_required;
+  params.check_ambiguity = 0;
+  params.print_errors = 1;
+
+  result = cmdline_parser_internal (argc, argv, args_info, &params, NULL);
+
+  return result;
+}
+
+int
+cmdline_parser_required (struct gengetopt_args_info *args_info, const char *prog_name)
+{
+  return EXIT_SUCCESS;
+}
+
+
+static char *package_name = 0;
+
+/**
+ * @brief updates an option
+ * @param field the generic pointer to the field to update
+ * @param orig_field the pointer to the orig field
+ * @param field_given the pointer to the number of occurrence of this option
+ * @param prev_given the pointer to the number of occurrence already seen
+ * @param value the argument for this option (if null no arg was specified)
+ * @param possible_values the possible values for this option (if specified)
+ * @param default_value the default value (in case the option only accepts fixed values)
+ * @param arg_type the type of this option
+ * @param check_ambiguity @see cmdline_parser_params.check_ambiguity
+ * @param override @see cmdline_parser_params.override
+ * @param no_free whether to free a possible previous value
+ * @param multiple_option whether this is a multiple option
+ * @param long_opt the corresponding long option
+ * @param short_opt the corresponding short option (or '-' if none)
+ * @param additional_error possible further error specification
+ */
+static
+int update_arg(void *field, char **orig_field,
+               unsigned int *field_given, unsigned int *prev_given, 
+               char *value, char *possible_values[], const char *default_value,
+               cmdline_parser_arg_type arg_type,
+               int check_ambiguity, int override,
+               int no_free, int multiple_option,
+               const char *long_opt, char short_opt,
+               const char *additional_error)
+{
+  char *stop_char = 0;
+  const char *val = value;
+  int found;
+  char **string_field;
+
+  stop_char = 0;
+  found = 0;
+
+  if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
+    {
+      if (short_opt != '-')
+        fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n", 
+               package_name, long_opt, short_opt,
+               (additional_error ? additional_error : ""));
+      else
+        fprintf (stderr, "%s: `--%s' option given more than once%s\n", 
+               package_name, long_opt,
+               (additional_error ? additional_error : ""));
+      return 1; /* failure */
+    }
+
+    
+  if (field_given && *field_given && ! override)
+    return 0;
+  if (prev_given)
+    (*prev_given)++;
+  if (field_given)
+    (*field_given)++;
+  if (possible_values)
+    val = possible_values[found];
+
+  switch(arg_type) {
+  case ARG_FLAG:
+    *((int *)field) = !*((int *)field);
+    break;
+  case ARG_INT:
+    if (val) *((int *)field) = strtol (val, &stop_char, 0);
+    break;
+  case ARG_STRING:
+    if (val) {
+      string_field = (char **)field;
+      if (!no_free && *string_field)
+        free (*string_field); /* free previous string */
+      *string_field = gengetopt_strdup (val);
+    }
+    break;
+  default:
+    break;
+  };
+
+  /* check numeric conversion */
+  switch(arg_type) {
+  case ARG_INT:
+    if (val && !(stop_char && *stop_char == '\0')) {
+      fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val);
+      return 1; /* failure */
+    }
+    break;
+  default:
+    ;
+  };
+
+  /* store the original value */
+  switch(arg_type) {
+  case ARG_NO:
+  case ARG_FLAG:
+    break;
+  default:
+    if (value && orig_field) {
+      if (no_free) {
+        *orig_field = value;
+      } else {
+        if (*orig_field)
+          free (*orig_field); /* free previous string */
+        *orig_field = gengetopt_strdup (value);
+      }
+    }
+  };
+
+  return 0; /* OK */
+}
+
+
+int
+cmdline_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
+                        struct cmdline_parser_params *params, const char *additional_error)
+{
+  int c;	/* Character of the parsed option.  */
+
+  int error = 0;
+  struct gengetopt_args_info local_args_info;
+  
+  int override;
+  int initialize;
+  int check_required;
+  int check_ambiguity;
+  
+  package_name = argv[0];
+  
+  override = params->override;
+  initialize = params->initialize;
+  check_required = params->check_required;
+  check_ambiguity = params->check_ambiguity;
+
+  if (initialize)
+    cmdline_parser_init (args_info);
+
+  cmdline_parser_init (&local_args_info);
+
+  optarg = 0;
+  optind = 0;
+  opterr = params->print_errors;
+  optopt = '?';
+
+  while (1)
+    {
+      int option_index = 0;
+
+      static struct option long_options[] = {
+        { "help",	0, NULL, 'h' },
+        { "version",	0, NULL, 'V' },
+        { "ndirectory",	1, NULL, 'n' },
+        { "directory",	1, NULL, 'd' },
+        { "gibbs",	1, NULL, 'g' },
+        { "zero",	0, NULL, 'z' },
+        { "zeros",	1, NULL, 'Z' },
+        { "genex",	1, NULL, 'G' },
+        { "subsample",	1, NULL, 's' },
+        { "memmap",	0, NULL, 'm' },
+        { "random",	1, NULL, 'r' },
+        { "verbosity",	1, NULL, 'v' },
+        { NULL,	0, NULL, 0 }
+      };
+
+      c = getopt_long (argc, argv, "hVn:d:g:zZ:G:s:mr:v:", long_options, &option_index);
+
+      if (c == -1) break;	/* Exit from `while (1)' loop.  */
+
+      switch (c)
+        {
+        case 'h':	/* Print help and exit.  */
+          cmdline_parser_print_help ();
+          cmdline_parser_free (&local_args_info);
+          exit (EXIT_SUCCESS);
+
+        case 'V':	/* Print version and exit.  */
+        
+        
+          if (update_arg( 0 , 
+               0 , &(args_info->version_given),
+              &(local_args_info.version_given), optarg, 0, 0, ARG_NO,
+              check_ambiguity, override, 0, 0,
+              "version", 'V',
+              additional_error))
+            goto failure;
+          cmdline_parser_free (&local_args_info);
+          return 0;
+        
+          break;
+        case 'n':	/* Input directory.  */
+        
+        
+          if (update_arg( (void *)&(args_info->ndirectory_arg), 
+               &(args_info->ndirectory_orig), &(args_info->ndirectory_given),
+              &(local_args_info.ndirectory_given), optarg, 0, ".", ARG_STRING,
+              check_ambiguity, override, 0, 0,
+              "ndirectory", 'n',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'd':	/* Output directory.  */
+        
+        
+          if (update_arg( (void *)&(args_info->directory_arg), 
+               &(args_info->directory_orig), &(args_info->directory_given),
+              &(local_args_info.directory_given), optarg, 0, ".", ARG_STRING,
+              check_ambiguity, override, 0, 0,
+              "directory", 'd',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'g':	/* Gibbs run.  */
+        
+        
+          if (update_arg( (void *)&(args_info->gibbs_arg), 
+               &(args_info->gibbs_orig), &(args_info->gibbs_given),
+              &(local_args_info.gibbs_given), optarg, 0, "100000", ARG_INT,
+              check_ambiguity, override, 0, 0,
+              "gibbs", 'g',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'z':	/* Zero missing values.  */
+        
+        
+          if (update_arg((void *)&(args_info->zero_flag), 0, &(args_info->zero_given),
+              &(local_args_info.zero_given), optarg, 0, 0, ARG_FLAG,
+              check_ambiguity, override, 1, 0, "zero", 'z',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'Z':	/* Read zeroed node IDs/outputs from the given file.  */
+        
+        
+          if (update_arg( (void *)&(args_info->zeros_arg), 
+               &(args_info->zeros_orig), &(args_info->zeros_given),
+              &(local_args_info.zeros_given), optarg, 0, 0, ARG_STRING,
+              check_ambiguity, override, 0, 0,
+              "zeros", 'Z',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'G':	/* Gene exclusion file.  */
+        
+        
+          if (update_arg( (void *)&(args_info->genex_arg), 
+               &(args_info->genex_orig), &(args_info->genex_given),
+              &(local_args_info.genex_given), optarg, 0, 0, ARG_STRING,
+              check_ambiguity, override, 0, 0,
+              "genex", 'G',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 's':	/* Maximum pairs to subsample.  */
+        
+        
+          if (update_arg( (void *)&(args_info->subsample_arg), 
+               &(args_info->subsample_orig), &(args_info->subsample_given),
+              &(local_args_info.subsample_given), optarg, 0, "100000", ARG_INT,
+              check_ambiguity, override, 0, 0,
+              "subsample", 's',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'm':	/* Memory map input/output.  */
+        
+        
+          if (update_arg((void *)&(args_info->memmap_flag), 0, &(args_info->memmap_given),
+              &(local_args_info.memmap_given), optarg, 0, 0, ARG_FLAG,
+              check_ambiguity, override, 1, 0, "memmap", 'm',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'r':	/* Seed random generator.  */
+        
+        
+          if (update_arg( (void *)&(args_info->random_arg), 
+               &(args_info->random_orig), &(args_info->random_given),
+              &(local_args_info.random_given), optarg, 0, "0", ARG_INT,
+              check_ambiguity, override, 0, 0,
+              "random", 'r',
+              additional_error))
+            goto failure;
+        
+          break;
+        case 'v':	/* Message verbosity.  */
+        
+        
+          if (update_arg( (void *)&(args_info->verbosity_arg), 
+               &(args_info->verbosity_orig), &(args_info->verbosity_given),
+              &(local_args_info.verbosity_given), optarg, 0, "5", ARG_INT,
+              check_ambiguity, override, 0, 0,
+              "verbosity", 'v',
+              additional_error))
+            goto failure;
+        
+          break;
+
+        case 0:	/* Long option with no short option */
+        case '?':	/* Invalid option.  */
+          /* `getopt_long' already printed an error message.  */
+          goto failure;
+
+        default:	/* bug: option not considered.  */
+          fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : ""));
+          abort ();
+        } /* switch */
+    } /* while */
+
+
+
+
+  cmdline_parser_release (&local_args_info);
+
+  if ( error )
+    return (EXIT_FAILURE);
+
+  if (optind < argc)
+    {
+      int i = 0 ;
+      int found_prog_name = 0;
+      /* whether program name, i.e., argv[0], is in the remaining args
+         (this may happen with some implementations of getopt,
+          but surely not with the one included by gengetopt) */
+
+      i = optind;
+      while (i < argc)
+        if (argv[i++] == argv[0]) {
+          found_prog_name = 1;
+          break;
+        }
+      i = 0;
+
+      args_info->inputs_num = argc - optind - found_prog_name;
+      args_info->inputs =
+        (char **)(malloc ((args_info->inputs_num)*sizeof(char *))) ;
+      while (optind < argc)
+        if (argv[optind++] != argv[0])
+          args_info->inputs[ i++ ] = gengetopt_strdup (argv[optind-1]) ;
+    }
+
+  return 0;
+
+failure:
+  
+  cmdline_parser_release (&local_args_info);
+  return (EXIT_FAILURE);
+}

tools/SpeciesConnector/cmdline.h

+/** @file cmdline.h
+ *  @brief The header file for the command line option parser
+ *  generated by GNU Gengetopt version 2.22
+ *  http://www.gnu.org/software/gengetopt.
+ *  DO NOT modify this file, since it can be overwritten
+ *  @author GNU Gengetopt by Lorenzo Bettini */
+
+#ifndef CMDLINE_H
+#define CMDLINE_H
+
+/* If we use autoconf.  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h> /* for FILE */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef CMDLINE_PARSER_PACKAGE
+/** @brief the program name */
+#define CMDLINE_PARSER_PACKAGE "SpeciesConnector"
+#endif
+
+#ifndef CMDLINE_PARSER_VERSION
+/** @brief the program version */
+#define CMDLINE_PARSER_VERSION "1.0"
+#endif
+
+/** @brief Where the command line options are stored */
+struct gengetopt_args_info
+{
+  const char *help_help; /**< @brief Print help and exit help description.  */
+  const char *version_help; /**< @brief Print version and exit help description.  */
+  char * ndirectory_arg;	/**< @brief Input directory (default='.').  */
+  char * ndirectory_orig;	/**< @brief Input directory original value given at command line.  */
+  const char *ndirectory_help; /**< @brief Input directory help description.  */
+  char * directory_arg;	/**< @brief Output directory (default='.').  */
+  char * directory_orig;	/**< @brief Output directory original value given at command line.  */
+  const char *directory_help; /**< @brief Output directory help description.  */
+  int gibbs_arg;	/**< @brief Gibbs run (default='100000').  */
+  char * gibbs_orig;	/**< @brief Gibbs run original value given at command line.  */
+  const char *gibbs_help; /**< @brief Gibbs run help description.  */
+  int zero_flag;	/**< @brief Zero missing values (default=off).  */
+  const char *zero_help; /**< @brief Zero missing values help description.  */
+  char * zeros_arg;	/**< @brief Read zeroed node IDs/outputs from the given file.  */
+  char * zeros_orig;	/**< @brief Read zeroed node IDs/outputs from the given file original value given at command line.  */
+  const char *zeros_help; /**< @brief Read zeroed node IDs/outputs from the given file help description.  */
+  char * genex_arg;	/**< @brief Gene exclusion file.  */
+  char * genex_orig;	/**< @brief Gene exclusion file original value given at command line.  */
+  const char *genex_help; /**< @brief Gene exclusion file help description.  */
+  int subsample_arg;	/**< @brief Maximum pairs to subsample (default='100000').  */
+  char * subsample_orig;	/**< @brief Maximum pairs to subsample original value given at command line.  */
+  const char *subsample_help; /**< @brief Maximum pairs to subsample help description.  */
+  int memmap_flag;	/**< @brief Memory map input/output (default=off).  */
+  const char *memmap_help; /**< @brief Memory map input/output help description.  */
+  int random_arg;	/**< @brief Seed random generator (default='0').  */
+  char * random_orig;	/**< @brief Seed random generator original value given at command line.  */
+  const char *random_help; /**< @brief Seed random generator help description.  */
+  int verbosity_arg;	/**< @brief Message verbosity (default='5').  */
+  char * verbosity_orig;	/**< @brief Message verbosity original value given at command line.  */
+  const char *verbosity_help; /**< @brief Message verbosity help description.  */
+  
+  unsigned int help_given ;	/**< @brief Whether help was given.  */
+  unsigned int version_given ;	/**< @brief Whether version was given.  */
+  unsigned int ndirectory_given ;	/**< @brief Whether ndirectory was given.  */
+  unsigned int directory_given ;	/**< @brief Whether directory was given.  */
+  unsigned int gibbs_given ;	/**< @brief Whether gibbs was given.  */
+  unsigned int zero_given ;	/**< @brief Whether zero was given.  */
+  unsigned int zeros_given ;	/**< @brief Whether zeros was given.  */
+  unsigned int genex_given ;	/**< @brief Whether genex was given.  */
+  unsigned int subsample_given ;	/**< @brief Whether subsample was given.  */
+  unsigned int memmap_given ;	/**< @brief Whether memmap was given.  */
+  unsigned int random_given ;	/**< @brief Whether random was given.  */
+  unsigned int verbosity_given ;	/**< @brief Whether verbosity was given.  */
+
+  char **inputs ; /**< @brief unamed options (options without names) */
+  unsigned inputs_num ; /**< @brief unamed options number */
+} ;
+
+/** @brief The additional parameters to pass to parser functions */
+struct cmdline_parser_params
+{
+  int override; /**< @brief whether to override possibly already present options (default 0) */
+  int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 1) */
+  int check_required; /**< @brief whether to check that all required options were provided (default 1) */
+  int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */
+  int print_errors; /**< @brief whether getopt_long should print an error message for a bad option (default 1) */
+} ;
+
+/** @brief the purpose string of the program */
+extern const char *gengetopt_args_info_purpose;
+/** @brief the usage string of the program */
+extern const char *gengetopt_args_info_usage;
+/** @brief all the lines making the help output */
+extern const char *gengetopt_args_info_help[];
+
+/**
+ * The command line parser
+ * @param argc the number of command line options
+ * @param argv the command line options
+ * @param args_info the structure where option information will be stored
+ * @return 0 if everything went fine, NON 0 if an error took place
+ */
+int cmdline_parser (int argc, char * const *argv,
+  struct gengetopt_args_info *args_info);
+
+/**
+ * The command line parser (version with additional parameters - deprecated)
+ * @param argc the number of command line options
+ * @param argv the command line options
+ * @param args_info the structure where option information will be stored
+ * @param override whether to override possibly already present options
+ * @param initialize whether to initialize the option structure my_args_info
+ * @param check_required whether to check that all required options were provided
+ * @return 0 if everything went fine, NON 0 if an error took place
+ * @deprecated use cmdline_parser_ext() instead
+ */
+int cmdline_parser2 (int argc, char * const *argv,
+  struct gengetopt_args_info *args_info,
+  int override, int initialize, int check_required);
+
+/**
+ * The command line parser (version with additional parameters)
+ * @param argc the number of command line options
+ * @param argv the command line options
+ * @param args_info the structure where option information will be stored
+ * @param params additional parameters for the parser
+ * @return 0 if everything went fine, NON 0 if an error took place
+ */
+int cmdline_parser_ext (int argc, char * const *argv,
+  struct gengetopt_args_info *args_info,
+  struct cmdline_parser_params *params);
+
+/**
+ * Save the contents of the option struct into an already open FILE stream.
+ * @param outfile the stream where to dump options
+ * @param args_info the option struct to dump
+ * @return 0 if everything went fine, NON 0 if an error took place
+ */
+int cmdline_parser_dump(FILE *outfile,
+  struct gengetopt_args_info *args_info);
+
+/**
+ * Save the contents of the option struct into a (text) file.
+ * This file can be read by the config file parser (if generated by gengetopt)
+ * @param filename the file where to save
+ * @param args_info the option struct to save
+ * @return 0 if everything went fine, NON 0 if an error took place
+ */
+int cmdline_parser_file_save(const char *filename,
+  struct gengetopt_args_info *args_info);
+
+/**
+ * Print the help
+ */
+void cmdline_parser_print_help(void);
+/**
+ * Print the version
+ */
+void cmdline_parser_print_version(void);
+
+/**
+ * Initializes all the fields a cmdline_parser_params structure 
+ * to their default values
+ * @param params the structure to initialize
+ */
+void cmdline_parser_params_init(struct cmdline_parser_params *params);
+
+/**
+ * Allocates dynamically a cmdline_parser_params structure and initializes
+ * all its fields to their default values
+ * @return the created and initialized cmdline_parser_params structure
+ */
+struct cmdline_parser_params *cmdline_parser_params_create(void);
+
+/**
+ * Initializes the passed gengetopt_args_info structure's fields
+ * (also set default values for options that have a default)
+ * @param args_info the structure to initialize
+ */
+void cmdline_parser_init (struct gengetopt_args_info *args_info);
+/**
+ * Deallocates the string fields of the gengetopt_args_info structure
+ * (but does not deallocate the structure itself)
+ * @param args_info the structure to deallocate
+ */
+void cmdline_parser_free (struct gengetopt_args_info *args_info);
+
+/**
+ * Checks that all the required options were specified
+ * @param args_info the structure to check
+ * @param prog_name the name of the program that will be used to print
+ *   possible errors
+ * @return
+ */
+int cmdline_parser_required (struct gengetopt_args_info *args_info,
+  const char *prog_name);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* CMDLINE_H */

tools/SpeciesConnector/stdafx.cpp

+/*****************************************************************************
+* This file is provided under the Creative Commons Attribution 3.0 license.
+*
+* You are free to share, copy, distribute, transmit, or adapt this work
+* PROVIDED THAT you attribute the work to the authors listed below.
+* For more information, please see the following web page:
+* http://creativecommons.org/licenses/by/3.0/
+*
+* This file is a component of the Sleipnir library for functional genomics,
+* authored by:
+* Curtis Huttenhower (chuttenh@princeton.edu)
+* Mark Schroeder
+* Maria D. Chikina
+* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
+*
+* If you use this library, the included executable tools, or any related
+* code in your work, please cite the following publication:
+* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
+* Olga G. Troyanskaya.
+* "The Sleipnir library for computational functional genomics"
+*****************************************************************************/
+#include "stdafx.h"
+
+/*!
+ * \page SpeciesConnector SpeciesConnector
+ * 
+ * SpeciesConnector calculates the mutual information (or other similarity measure) between pairs of input datasets.
+ * This can be used to approximate how much information is shared between two experimental datasets or
+ * how similar two predicted functional relationship networks are.
+ * 
+ * \section sec_usage Usage
+ * 
+ * \subsection ssec_usage_basic Basic Usage
+ * 
+ * \code
+ * SpeciesConnector <data.dab>*
+ * \endcode
+ * 
+ * Compute pairwise mutual information scores for each pair of datasets in \c data.dab and output them to
+ * standard output.
+ * 
+ * \subsection ssec_usage_detailed Detailed Usage
+ * 
+ * Note that to use \ref Counter with the output from \c SpeciesConnector, you should first convert the table of raw
+ * (bit) mutual information scores to exponentially scaled sums of relative shared information.  This can
+ * be done using the \c half2relative.rb and \c half2weights.rb scripts included with Sleipnir.  The
+ * combination of these two files' outputs creates a weights file appropriate for use with \ref Counter 's
+ * alphas parameters.
+ * 
+ * \include SpeciesConnector/SpeciesConnector.ggo
+ * 
+ * <table><tr>
+ *	<th>Flag</th>
+ *	<th>Default</th>
+ *	<th>Type</th>
+ *	<th>Description</th>
+ * </tr><tr>
+ * 	<td>None</td>
+ * 	<td>None</td>
+ * 	<td>DAT/DAB files</td>
+ * 	<td>Datasets for which pairwise mutual information (or other similarity measure) will be calculated.</td>
+ * </tr><tr>
+ *	<td>-d</td>
+ *	<td>mi</td>
+ *	<td>mi, pearson, quickpear, euclidean, kendalls, kolm-smir, hypergeom, innerprod, bininnerprod</td>
+ *	<td>Similarity measure to be used for dataset comparisons.</td>
+ * </tr><tr>
+ *	<td>-z</td>
+ *	<td>off</td>
+ *	<td>Flag</td>
+ *	<td>If on, assume that all missing gene pairs in all datasets have a value of 0 (i.e. the first bin).</td>
+ * </tr><tr>
+ *	<td>-Z</td>
+ *	<td>None</td>
+ *	<td>Tab-delimited text file</td>
+ *	<td>If given, argument must be a tab-delimited text file containing two columns, the first node
+ *		IDs (see \ref BNCreator) and the second bin numbers (zero indexed).  For each node ID present in
+ *		this file, missing values will be substituted with the given bin number.</td>
+ * </tr><tr>
+ *	<td>-R</td>
+ *	<td>on</td>
+ *	<td>Flag</td>
+ *	<td>If on, assign missing values randomly; this generally results in much better approximations of
+ *		mutual information.</td>
+ * </tr><tr>
+ *	<td>-t</td>
+ *	<td>on</td>
+ *	<td>Flag</td>
+ *	<td>If on, format output as a tab-delimited table; otherwise, format as one pair per line.</td>
+ * </tr><tr>
+ *	<td>-y</td>
+ *	<td>-1</td>
+ *	<td>Integer</td>
+ *	<td>If nonnegative, process only pairs of datasets containing (and beginning with) the given dataset
+ *		index.  This can be used to parallelize many mutual information calculations by running
+ *		processes with different \c -y values.</td>
+ * </tr><tr>
+ *	<td>-m</td>
+ *	<td>off</td>
+ *	<td>Flag</td>
+ *	<td>If given, memory map the input files when possible.  DAT and PCL inputs cannot be memmapped.</td>
+ * </tr></table>
+ */

tools/SpeciesConnector/stdafx.h

+/*****************************************************************************
+* This file is provided under the Creative Commons Attribution 3.0 license.
+*
+* You are free to share, copy, distribute, transmit, or adapt this work
+* PROVIDED THAT you attribute the work to the authors listed below.
+* For more information, please see the following web page:
+* http://creativecommons.org/licenses/by/3.0/
+*
+* This file is a component of the Sleipnir library for functional genomics,
+* authored by:
+* Curtis Huttenhower (chuttenh@princeton.edu)
+* Mark Schroeder
+* Maria D. Chikina
+* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
+*
+* If you use this library, the included executable tools, or any related
+* code in your work, please cite the following publication:
+* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
+* Olga G. Troyanskaya.
+* "The Sleipnir library for computational functional genomics"
+*****************************************************************************/
+#ifndef STDAFX_H
+#define STDAFX_H
+
+#include <direct.h>
+#include <fstream>
+//#include <cstring>
+//#include <cctype>
+using namespace std;
+
+#include <pthread.h>
+
+#include "bayesnet.h"
+#include "dataset.h"
+#include "genome.h"
+#include "meta.h"
+//#include "string.h"
+using namespace Sleipnir;
+
+#ifndef _MSC_VER
+#include <dirent.h>
+
+#define _unlink	unlink
+#endif // _MSC_VER
+
+#endif // STDAFX_H
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.