Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/sequence__display_8cpp_source.html below:

NCBI C++ ToolKit: src/app/cn3d/sequence_display.cpp Source File

((colorVec[0] + 0.000001) * 255),

((colorVec[1] + 0.000001) * 255),

((colorVec[2] + 0.000001) * 255)

*drawBackground,

*cellBackgroundColor)

&isHighlighted, drawBackground, cellBackgroundColor);

*drawBackground =

;

sequence(s), fromIndex(from), toIndex(to)

(

);

*character,

*

,

*drawBackground,

*cellBackgroundColor)

*drawBackground =

;

*drawBackground =

;

**sequenceHandle,

*seqIndex)

*character,

*

,

*drawBackground,

*cellBackgroundColor)

*drawBackground =

;

*drawBackground =

;

isEditable(editable), viewerWindow(parentViewerWindow), startingColumn(0), maxRowWidth(0)

(

=0;

<

.size(); ++

)

[

];

(

=0;

<

.size(); ++

)

[

];

->rows.push_back(

[

]->Clone(newAlignments));

(displayRow)

displayRow->

;

(stringRow)

stringRow->

;

RowVector::iterator

, re =

.end();

(

=

.begin();

!=re; ++

)

(!fromAlignment ||

>= fromAlignment->

()) {

(

);

(

);

(strRow && !strRow->

.empty()) {

*title = strRow->

.c_str();

(!sequence)

;

*character, wxColour *

,

*drawBackground,

wxColour *cellBackgroundColor)

(

);

colorVec, bgColorVec;

character, &colorVec, drawBackground, &bgColorVec))

(*drawBackground)

(bgColorVec, cellBackgroundColor);

wxString idLoc, status;

(

>= 0 &&

< (

)

.size()) {

(*viewerWindow)->GetCurrentJustification(), &sequence, &index)) {

idLoc.Printf(

, title.c_str(), index + 1);

(sequence && index >= 0 && sequence->

) {

(residue && residue->

.size() > 0) {

wxString

= residue->

.c_str();

=

.Strip(wxString::both);

idLoc = idLoc +

+

+

;

(

=0;

<=

; ++

) {

status.Printf(

, blockNum, rowNum);

status.Printf(

, rowNum);

idLoc.Printf(

, sequence->

());

(*viewerWindow)->SetStatusText(idLoc, 0);

(*viewerWindow)->SetStatusText(status, 1);

(*viewerWindow)->viewer->Save();

(*viewerWindow)->UpdateDisplay(

);

((*viewerWindow)->AlwaysSyncStructures())

(*viewerWindow)->SyncStructures();

(column < 0 && row >= 0 &&

< (

)

()) {

(alignment &&

>= 0) {

((*viewerWindow)->DoSplitBlock()) {

(!

) (*viewerWindow)->SplitBlockOff();

((*viewerWindow)->DoDeleteBlock()) {

(!

) (*viewerWindow)->DeleteBlockOff();

(sequenceWindow &&

>= 0) {

(!selectedRow || selectedRow->

== 0 || !selectedRow->

) {

(

);

vector < unsigned int > selectedDependents(1);

selectedDependents[0] = selectedRow->

;

(alignment->

() <= 2) {

RowVector::iterator

, re =

.end(), toDelete;

(

=

.begin();

!=re; ++

) {

(currentARow->

> selectedRow->

)

(currentARow->

)--;

(currentARow == selectedRow)

.erase(toDelete);

(updateWindow &&

>= 0) {

(

);

(optDialog.ShowModal() == wxCANCEL)

;

(

);

(dialog.ShowModal() == wxOK) {

(

);

(

<< from <<

<< to);

single[alignment] =

;

single[alignment] =

;

columnRight,

rowBottom)

(

<< columnLeft <<

<< rowTop <<

<< columnRight <<

<< rowBottom);

(*viewerWindow)->GetCurrentJustification();

(singleAlignment) {

((*viewerWindow)->DoMergeBlocks()) {

(alignment->

(columnLeft, columnRight)) {

(!

) (*viewerWindow)->MergeBlocksOff();

((*viewerWindow)->DoCreateBlock()) {

(alignment->

(columnLeft, columnRight, justification)) {

(!

) (*viewerWindow)->CreateBlockOff();

(singleAlignment && (*viewerWindow)->SelectBlocksIsOn()) {

(

=rowTop;

<=rowBottom; ++

)

[

]->SelectedRange(columnLeft, columnRight, justification,

);

columnTo,

rowTo)

(columnFrom == columnTo && rowFrom == rowTo) {

(alnBlockNum > 0) {

(alnRow && alignment->

(alnRow->

, columnFrom, (*viewerWindow)->GetCurrentJustification()))

, (*viewerWindow)->GetCurrentJustification()))

(

<< columnFrom <<

<< rowFrom <<

<< columnTo <<

<< rowTo);

(rowFrom == rowTo && columnFrom == columnTo)

;

(rowFrom != rowTo && columnFrom != columnTo)

;

(columnFrom != columnTo) {

ch = strRow->

[columnFrom];

(alignment->

(alnRow->

, columnFrom, columnTo,

(*viewerWindow)->GetCurrentJustification()))

(rowFrom == rowTo - 1)

;

(rowTo > rowFrom) --rowTo;

RowVector::iterator

= newRows.begin();

(

=0;

<rowFrom; ++

) ++

;

(

=newRows.begin(),

=0;

<rowTo; ++

) ++

;

newRows.insert(

,

);

masterOK =

;

(

=0;

<(

)newRows.size(); ++

) {

(alnRow->

!= 0) {

(

);

(*viewerWindow)->UpdateDisplay(

);

(*viewerWindow)->viewer->Save();

(

=0;

<

.size(); ++

) {

(sequence && sequence->

)

(blockBoundaryRow->

== forAlignment &&

blockBoundaryRow =

;

blockBoundaryRow;

RowVector::iterator

;

(

=

.begin(),

=0;

<

.size(); ++

, ++

) {

(!alnRow || alnRow->

!= 0 || !alnRow->

||

doneForAlignment.

(alnRow->

) != doneForAlignment.

())

;

.insert(

, blockBoundaryRow);

doneForAlignment[alnRow->

] =

;

}

(

<

.size());

(*

) (*viewerWindow)->UpdateDisplay(

);

(blockBoundaryRow);

blockBoundaryRow->

.resize(alignmentWidth);

blockColumn, blockWidth;

(

=0;

<alignmentWidth; ++

) {

(blockColumn >= 0 && blockWidth > 0) {

(blockColumn == 0)

(blockColumn == blockWidth - 1)

vector < bool > toRemove(

.size(),

);

nToRemove = 0;

blockBoundaryRow;

toRemove[

] =

;

(*

) (*viewerWindow)->UpdateDisplay(

);

seqs->push_back(seq);

(alnRow && alnRow->

== forAlignment)

dependentRowOrder->clear();

(alnRow && alnRow->

== forAlignment)

dependentRowOrder->push_back(alnRow->

);

(dependentRowOrder->size() != forAlignment->

() || dependentRowOrder->front() != 0)

(

);

->alignment->GetSequenceOfRow(

->row)->identifier,

->alignment->GetSequenceOfRow(

->row)->identifier);

(

->alignment->GetRowDouble(

->row) >

->alignment->GetRowDouble(

->row));

((

->alignment->GetRowDouble(

->row) >= 0.0 &&

->alignment->GetRowDouble(

->row) <

->alignment->GetRowDouble(

->row)) ||

->alignment->GetRowDouble(

->row) < 0.0);

(

->alignment->GetSequenceOfRow(

->row)->identifier->pdbID.size() > 0 &&

->alignment->GetSequenceOfRow(

->row)->identifier->pdbID.size() == 0);

(

()->IsHighlightedAnywhere(

->alignment->GetSequenceOfRow(

->row)->identifier) &&

!

()->IsHighlightedAnywhere(

->alignment->GetSequenceOfRow(

->row)->identifier));

(

);

((*viewerWindow)->viewer->alignmentManager->threader->

(*viewerWindow)->viewer->CalculateSelfHitScores(alnRow->

);

(

);

vector < DisplayRowFromAlignment * > dependents;

(alnRow && alnRow->

> 0)

dependents.push_back(alnRow);

nDependents = 0;

(alnRow && alnRow->

> 0)

newRows[

] = dependents[nDependents++];

(nDependents == dependents.size())

(

);

(*viewerWindow)->viewer->Save();

(*viewerWindow)->UpdateDisplay(

);

(!keyRow || keyRow->

== 0)

;

(

<< keyRow->

);

BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator

, be =

.end();

vector < DisplayRowFromAlignment * > sortedByScore;

(!alnRow)

;

sortedByScore.push_back(alnRow);

(alnRow == keyRow) {

(

=

.begin();

!=be; ++

) {

*

= (*b)->GetRangeOfRow(keyRow->

),

*

= (*b)->GetRangeOfRow(alnRow->

);

(

=0;

<(*b)->width; ++

)

(

);

(

=0;

<sortedByScore.size(); ++

)

(sortedByScore[

]->

== 0)

;

vector < DisplayRowFromAlignment * > arrangedByProximity(sortedByScore.size(),

);

arrangedByProximity[0] = sortedByScore[

];

arrangedByProximity[

] = sortedByScore[0];

vector < bool > toRemove(sortedByScore.size(),

);

toRemove[

] = toRemove[0] =

;

= 1, j = 1,

;

(

< sortedByScore.size()) {

(

> 0 &&

< (

)arrangedByProximity.size())

arrangedByProximity[

] = sortedByScore[

++];

nNewRows = 0;

newRows[

] = arrangedByProximity[nNewRows++];

(nNewRows == arrangedByProximity.size())

(

);

(*viewerWindow)->ScrollToRow((

- 3) > 0 ? (

- 3) : 0);

(*viewerWindow)->viewer->Save();

(*viewerWindow)->UpdateDisplay(

);

(

);

(nRowsAddedToMultiple == 0)

;

,

= 0, lastAlnRowIndex = 0;

displayWhere = -1;

(

=0;

<

.size(); ++

) {

(alnRow && alnRow->

== multiple) {

lastAlnRow = alnRow;

lastAlnRowIndex =

;

(alnWhere >= 0 && (

)alnRow->

== alnWhere)

(!lastAlnRow || multiple->

() !=

+ nRowsAddedToMultiple) {

(

);

rowToMergeAfter = (displayWhere >= 0) ? displayWhere : lastAlnRowIndex;

(

<< (rowToMergeAfter+1));

nRowsToMove =

.size() - 1 - rowToMergeAfter;

.resize(

.size() + nRowsAddedToMultiple);

(

=0;

<nRowsToMove; ++

)

(

=0;

<nRowsAddedToMultiple; ++

)

multiple->

() +

- nRowsAddedToMultiple, multiple);

(rowsRemoved.size() == 0)

;

vector < unsigned int > alnRowNumbers(multiple->

() + rowsRemoved.size());

vector < bool > removedAlnRows(alnRowNumbers.size(),

);

(

=0;

<alnRowNumbers.size(); ++

) alnRowNumbers[

] =

;

(

=0;

<rowsRemoved.size(); ++

) {

(rowsRemoved[

] < 1 || rowsRemoved[

] >= alnRowNumbers.size()) {

(

<< removedAlnRows[

]);

removedAlnRows[rowsRemoved[

]] =

;

(

=0;

<alnRowNumbers.size(); ++

) oldRowToNewRow[alnRowNumbers[

]] =

;

vector < bool > removeDisplayRows(

.size(),

);

(

=0;

<

.size(); ++

) {

(alnRow && alnRow->

== multiple) {

(removedAlnRows[alnRow->

]) {

removeDisplayRows[

] =

;

alnRow->

= oldRowToNewRow[alnRow->

];

(!molecule)

;

displayRow;

(displayRow=0; displayRow<

(); ++displayRow) {

seq =

[displayRow]->GetSequence();

(seq && seq->

== molecule) {

(seqRow && seqIndex >= seqRow->

&& seqIndex <= seqRow->toIndex) {

void BlockAlignUpdate(BlockMultipleAlignment *single)

void CalculateRowScoresWithThreader(double weightPSSM)

void RealignDependentSequences(BlockMultipleAlignment *multiple, const std::vector< unsigned int > &dependentsToRealign)

void ExtendUpdate(BlockMultipleAlignment *single)

std::map< BlockMultipleAlignment *, bool > UpdateMap

void ThreadUpdate(const ThreaderOptions &options, BlockMultipleAlignment *single)

const BlockMultipleAlignment * GetCurrentMultipleAlignment(void) const

void MergeUpdates(const UpdateMap &updates, bool mergeToNeighbor)

bool CreateBlock(unsigned int fromAlignmentIndex, unsigned int toAlignmentIndex, eUnalignedJustification justification)

void SelectBlocks(unsigned int alnIndexFrom, unsigned int alnIndexTo, bool toggle) const

bool ZipAlignResidue(unsigned int row, unsigned int alignmentIndex, bool moveRight, eUnalignedJustification justification)

unsigned int AlignmentWidth(void) const

bool MoveBlockBoundary(unsigned int columnFrom, unsigned int columnTo)

bool DeleteRow(unsigned int row)

bool MarkBlock(unsigned int column)

bool OptimizeBlock(unsigned int row, unsigned int alignmentIndex, eUnalignedJustification justification)

bool ShiftRow(unsigned int row, unsigned int fromAlignmentIndex, unsigned int toAlignmentIndex, eUnalignedJustification justification)

bool GetCharacterTraitsAt(unsigned int alignmentColumn, unsigned int row, eUnalignedJustification justification, char *character, Vector *color, bool *isHighlighted, bool *drawBackground, Vector *cellBackgroundColor) const

void SetRowDouble(unsigned int row, double value) const

void SetRowStatusLine(unsigned int row, const std::string &value) const

std::vector< const UngappedAlignedBlock * > UngappedAlignedBlockList

const Sequence * GetSequenceOfRow(unsigned int row) const

unsigned int GetAlignedBlockNumber(unsigned int alignmentIndex) const

void GetUngappedAlignedBlocks(UngappedAlignedBlockList *blocks) const

unsigned int GetAlignmentIndex(unsigned int row, unsigned int seqIndex, eUnalignedJustification justification)

unsigned int NRows(void) const

const std::string & GetRowStatusLine(unsigned int row) const

void GetAlignedBlockPosition(unsigned int alignmentIndex, unsigned int *blockColumn, unsigned int *blockWidth) const

bool DeleteBlock(unsigned int alignmentIndex)

bool MergeBlocks(unsigned int fromAlignmentIndex, unsigned int toAlignmentIndex)

bool SplitBlock(unsigned int alignmentIndex)

bool DeleteAllBlocks(void)

int GetLoopLength(unsigned int row, unsigned int alignmentIndex)

const Vector & Get(eColor which) const

bool GetCharacterTraitsAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const

BlockMultipleAlignment *const alignment

const Sequence *const sequence

DisplayRowFromSequence(const Sequence *s, unsigned int from, unsigned int to)

bool GetCharacterTraitsAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const

const unsigned int toIndex

bool GetSequenceAndIndexAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, const Sequence **sequenceHandle, int *index) const

void SelectedRange(unsigned int from, unsigned int to, BlockMultipleAlignment::eUnalignedJustification justification, bool toggle) const

const unsigned int fromIndex

BlockMultipleAlignment *const alignment

const bool hasBackgroundColor

const Vector backgroundColor

bool GetCharacterTraitsAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const

virtual bool GetSequenceAndIndexAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, const Sequence **sequence, int *index) const =0

virtual const Sequence * GetSequence(void) const =0

virtual unsigned int Width(void) const =0

virtual bool GetCharacterTraitsAt(unsigned int column, BlockMultipleAlignment::eUnalignedJustification justification, char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const =0

void ToggleHighlights(const Sequence *sequence, unsigned int seqIndexFrom, unsigned int seqIndexTo)

void PostRedrawMolecule(const Molecule *molecule)

void PostRedrawSequenceViewer(ViewerBase *viewer)

void KeepHighlightsOnlyOnSequence(const Sequence *sequence)

bool RemoveAllHighlights(bool postRedraws)

void PostRedrawAllSequenceViewers(void)

void AddHighlights(const Sequence *sequence, unsigned int seqIndexFrom, unsigned int seqIndexTo)

static bool CompareIdentifiers(const MoleculeIdentifier *a, const MoleculeIdentifier *b)

std::string ToString(void) const

Vector GetResidueColor(int sequenceIndex) const

bool GetValues(int *from, int *to)

bool GetRowTitle(unsigned int row, wxString *title, wxColour *color) const

bool GetCharacterTraitsAt(unsigned int column, unsigned int row, char *character, wxColour *color, bool *drawBackground, wxColour *cellBackgroundColor) const

bool ProximitySort(unsigned int displayRow)

bool CalculateRowScoresWithThreader(double weightPSSM)

void AddBlockBoundaryRows(void)

void FloatPDBRowsToTop(void)

BlockMultipleAlignment * GetAlignmentForRow(unsigned int row) const

DisplayRowFromString * FindBlockBoundaryRow(const BlockMultipleAlignment *forAlignment) const

void SortRowsByThreadingScore(double weightPSSM)

void AddRowFromAlignment(unsigned int row, BlockMultipleAlignment *fromAlignment)

void UpdateMaxRowWidth(void)

bool SortRowsByLoopLength(unsigned int row, unsigned int alnIndex)

unsigned int NRows(void) const

void AddRowFromString(const std::string &anyString)

void RedrawAlignedMolecules(void) const

void SortRowsBySelfHit(void)

void UpdateAfterEdit(const BlockMultipleAlignment *forAlignment)

void FloatHighlightsToTop(void)

SequenceDisplay * Clone(const Old2NewAlignmentMap &newAlignments) const

void GetProteinSequences(SequenceList *seqs) const

bool GetDisplayCoordinates(const Molecule *molecule, unsigned int seqIndex, BlockMultipleAlignment::eUnalignedJustification justification, unsigned int *column, unsigned int *row)

void RowsAdded(unsigned int nRowsAddedToMultiple, BlockMultipleAlignment *multiple, int where=-1)

SequenceDisplay(bool editable, ViewerWindowBase *const *parentViewerWindow)

virtual ~SequenceDisplay(void)

void AddRow(DisplayRow *row)

bool MouseDown(int column, int row, unsigned int controls)

void GetSequences(const BlockMultipleAlignment *forAlignment, SequenceList *seqs) const

void RemoveBlockBoundaryRows(void)

void RowsRemoved(const std::vector< unsigned int > &rowsRemoved, const BlockMultipleAlignment *multiple)

bool IsEditable(void) const

unsigned int startingColumn

void AddRowFromSequence(const Sequence *sequence, unsigned int from, unsigned int to)

ViewerWindowBase *const * viewerWindow

void GetRowOrder(const BlockMultipleAlignment *forAlignment, std::vector< unsigned int > *dependentRowOrder) const

void MouseOver(int column, int row) const

void DraggedCell(int columnFrom, int rowFrom, int columnTo, int rowTo)

std::vector< DisplayRow * > RowVector

void SortRowsByIdentifier(void)

void AddBlockBoundaryRow(BlockMultipleAlignment *forAlignment)

void UpdateBlockBoundaryRow(const BlockMultipleAlignment *forAlignment) const

std::vector< const Sequence * > SequenceList

void SelectedRectangle(int columnLeft, int rowTop, int columnRight, int rowBottom)

void RestrictHighlightsOff(void)

bool DoDeleteRow(void) const

SequenceViewer * sequenceViewer

bool DoProximitySort(void) const

bool DoRestrictHighlights(void) const

bool DoRealignRow(void) const

bool DoSortLoops(void) const

bool DoMarkBlock(void) const

void ProximitySortOff(void)

const Molecule * molecule

std::string GetDescription(void) const

const MoleculeIdentifier * identifier

unsigned int Length(void) const

void LaunchWebBrowserWithInfo(void) const

StyleManager * styleManager

const Vector & GetObjectColor(const Molecule *molecule) const

bool GetValues(ThreaderOptions *options)

std::vector< IntervalList > GeometryViolationsForRow

static unsigned int EstimateNRandomStarts(const BlockMultipleAlignment *coreAlignment, const BlockMultipleAlignment *toBeThreaded)

bool DoThreadSingle(void) const

bool DoBlastSingle(void) const

bool DoBlastPSSMSingle(void) const

void BlastPSSMSingleOff(void)

void MergeSingleOff(void)

bool DoMergeSingle(void) const

bool DoDeleteSingle(void) const

void BlockAlignSingleOff(void)

void DeleteAllBlocksOff(void)

bool DoExtendSingle(void) const

void BlastSingleOff(void)

bool DoBlockAlignSingle(void) const

UpdateViewer * updateViewer

bool DoSetRegion(void) const

bool DoBlastNeighborSingle(void) const

bool DoDeleteAllBlocks(void) const

bool DoMergeNeighbor(void) const

void BlastNeighborSingleOff(void)

void ThreadSingleOff(void)

void MergeNeighborOff(void)

void ExtendSingleOff(void)

void DeleteSingleOff(void)

void BlastUpdate(BlockMultipleAlignment *alignment, bool usePSSMFromMultiple)

void DeleteAlignment(BlockMultipleAlignment *toDelete)

void BlastNeighbor(BlockMultipleAlignment *update)

AlignmentManager * alignmentManager

bool AlwaysSyncStructures(void) const

const_iterator end() const

const_iterator find(const key_type &key) const

const Colors * GlobalColors(void)

ThreaderOptions globalThreaderOptions

Include a standard set of the NCBI C++ Toolkit most basic headers.

static const char * column

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_SCOPE(ns)

Define a new scope.

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

unsigned int

A callback function used to compare two keys in a database.

Messenger * GlobalMessenger(void)

The NCBI C++/STL use hints.

NCBI C++ stream class wrappers for triggering between "new" and "old" C++ stream libraries.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

static bool CompareRowsFloatGV(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static DisplayRowFromString * CreateBlockBoundaryRow(BlockMultipleAlignment *forAlignment)

static const char blockRightEdgeChar

bool(* CompareRows)(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static bool CompareRowsByScore(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static bool CompareRowsByIdentifier(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static void Vector2wxColor(const Vector &colorVec, wxColor *colorWX)

static const char blockLeftEdgeChar

static const char blockOneColumnChar

static bool CompareRowsFloatHighlights(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static const string blockBoundaryStringTitle("(blocks)")

static bool CompareRowsFloatPDB(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

static Threader::GeometryViolationsForRow violations

static const char blockInsideChar

static CompareRows rowComparisonFunction

static bool CompareRowsByEValue(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)

std::map< BlockMultipleAlignment *, BlockMultipleAlignment * > Old2NewAlignmentMap

static const sljit_gpr r1

static const sljit_gpr r2

#define row(bind, expected)

static DP_BlockInfo * blocks

static int GetBLOSUM62Score(char a, char b)

void VectorRemoveElements(std::vector< T > &v, const std::vector< bool > &remove, unsigned int nToRemove)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4