Lesen einer Zeichenkette unbekannter Länge

Ich wurden beauftragt mit dem schreiben einer Fortran-95-Programm auf das Lesen von Eingabezeichen aus einer Datei, und dann (beginnen mit) einfach spucken es wieder heraus.
Der schwierige Teil ist, dass diese Zeilen von input sind von unterschiedlicher Länge (Länge nicht angegeben) und es kann eine beliebige Anzahl von Zeilen innerhalb der Datei.

Ich verwendet habe,

    do
      read( 1, *, iostat = IO ) DNA    ! reads to EOF -- GOOD!!
      if ( IO < 0 ) exit               ! if EOF is reached, exit do
      I = I + 1
      NumRec = I                       ! used later for total no. of records
      allocate( Seq(I) )
      Seq(I) = DNA
      print*, I, Seq(I)
      X = Len_Trim( Seq(I) )           ! length of individual sequence
      print*, 'Sequence size: ', X
      print*
    end do

Jedoch meine anfänglichen Aussagen-Liste

    character(100), dimension(:), allocatable :: Seq
    character(100)  DNA

und die entsprechenden ganzen zahlen etc.

Ich denke, was ich verlange ist, wenn es irgendeinen Weg gibt, um NICHT die Größe der Zeichenketten in der ersten Instanz. Sagen, ich habe einen DNA-Strang, die 200+ Zeichen, und dann noch nur 25, gibt es eine Möglichkeit, dass das Programm nur Lesen können, was da ist und nicht brauchen, um alle zusätzlichen Leerzeichen? Kann das getan werden, ohne die Verwendung len_trim, da kann es nicht sein, auf die in der Erklärung Aussagen?

Es gibt einen Unterschied zwischen ein wenig Lesen einer Zeile (in Fortran-Terminologie - ein Rekord), machen einige Verarbeitung auf das bisschen, lese ein bisschen mehr auf der gleichen Linie, - Verarbeitung, bit, usw., im Gegensatz zum Lesen in die komplette Linie und dann machen einige Verarbeitung auf, dass die komplette Zeile (einem Dritten Fall liest die gesamte Datei und dann die Verarbeitung der gesamten Datei). Die erste ist leicht in Fortran 95 - Verwendung des nicht-voran-Eingang. Das zweite ist ... ein wenig chaotisch. Was wollen Sie? Beide sind leicht in Fortran 2003 - muss man sich an F95?
Leider habe ich nur Zugriff auf f95, wie ich bin mit meinen Vorgesetzten computer/software etc. Natürlich die einfachen ist vorzuziehen, aber vielleicht geben Sie mir beide? Danke!

InformationsquelleAutor | 2013-02-08

10

Schrittweisen Lesen eines Datensatzes in Fortran 95, verwenden Sie nicht-voran-Eingang. Zum Beispiel:
```
CHARACTER(10) :: buffer
INTEGER :: size
READ (unit, "(A)", ADVANCE='NO', SIZE=size, EOR=10, END=20) buffer
```
Lesen bis zu 10 Zeichen Wert (die Länge von buffer) jedes mal, wenn es aufgerufen wird. Die Datei wird dann weiter zum nächsten record (die nächste Zeile) einmal wird der gesamte Datensatz gelesen wurde, eine Reihe von ein oder mehr nicht-advancing liest.

Abgesehen von einem end of file-Bedingung, die size variable definiert, mit der tatsächlichen Anzahl von Zeichen Lesen Sie in buffer jedes mal, wenn die read-Anweisung ausgeführt wird.

Den EOR und END - und-Bezeichner werden verwendet, um die Kontrolle ausführungsablauf (execution springen, um die entsprechend gekennzeichnete Anweisung), wenn das Ende der Aufzeichnung oder das Ende der Datei Bedingungen auftreten, beziehungsweise. Sie können auch eine IOSTAT Bezeichner zu erkennen, diese Bedingungen, sondern insbesondere die negativen Werte für die zwei Bedingungen sind prozessorabhängig.

Können Sie die Summe size innerhalb eines bestimmten Datensatzes, um die Länge des jeweiligen Datensatzes.

Wrap solchen nicht fortschreitenden Lesen Sie in einer Schleife, die entsprechend erkennt zum Ende der Datei und das Ende der Aufzeichnung, und Sie haben die inkrementelle Lesen Teil.

In Fortran 95, die Länge Spezifikation für eine lokale Zeichenvariable muss eine Spezifikation Ausdruck - im wesentlichen ein Ausdruck, der sicher sein kann, bewertet vor der ersten ausführbaren Anweisung des Bereichs, enthält die variable in der Erklärung. Konstanten repräsentieren den einfachsten Fall, aber eine Spezifikation Ausdruck in ein Verfahren einbeziehen können, um dummy-Argumente, die der Prozedur, unter anderem.

Lesen Sie den gesamten Datensatz beliebiger Länge, ist dann ein multi-stage process:
- Bestimmen Sie die Länge des aktuellen Datensatzes mit einer Reihe von inkrementellen liest. Diese inkrementelle liest sich für einen bestimmten Datensatz zu Ende, wenn das Ende der Aufzeichnung Zustand Eintritt, zu welchem Zeitpunkt die Akte position wird zum nächsten Datensatz verschoben.
- Backspace die Datei wieder zu dem Datensatz von Interesse.
- Eine Prozedur aufrufen, übergeben Sie die Länge des aktuellen Datensatzes als dummy-argument. Innerhalb dieses Verfahrens haben eine Zeichen-variable, deren Länge gegeben ist durch die dummy-argument.
- Innen, die genannten Verfahren, Lesen Sie den aktuellen Datensatz in die character-variable mit normalen voran Eingang.
- Durchführung weiterer Verarbeitung auf, die Zeichen variable!
Beachten Sie, dass jeder Datensatz endet als zweimal Lesen - einmal, um zu bestimmen, seine Länge, die zweite, um wirklich zu Lesen, die Daten in die richtige "lengthed" Charakter Variablen.

Alternative Ansätze existieren, die die Verwendung belegbar (oder automatische) Zeichen-arrays der Länge eins. Die Allgemeine Strategie ist die gleiche. Blick auf die code von der Get-Verfahren in den gemeinsamen ISO_VARYING_STRING Umsetzung für ein Beispiel.

Fortran 2003 führt latenten Länge von character Variablen, die von Ihrer Länge angegeben, die durch einen beliebigen Ausdruck in einer allocate-Anweisung oder für belegbar Variablen, die durch die Länge der rechten Seite einer Zuweisungsanweisung. Dies (in Verbindung mit anderen "belegbar" - Erweiterungen) ermöglicht es, den progressiven Lesen, die bestimmt die Länge der Aufzeichnung zu bauen auch das character-variable, enthält den Inhalt des Datensatzes. Ihr Vorgesetzter bringt seine Fortran-Umgebung auf dem neuesten Stand.

InformationsquelleAutor IanH

Hier ist eine Funktion für Fortran 2003, das setzt eine belegbar string (InLine) der genau die Länge der Eingabe-Zeichenkette (Optional getrimmt), oder zurück .falsch. wenn das Ende der Datei

function ReadLine(aunit, InLine, trimmed) result(OK)
integer, intent(IN) :: aunit
character(LEN=:), allocatable, optional :: InLine
logical, intent(in), optional :: trimmed
integer, parameter :: line_buf_len= 1024*4
character(LEN=line_buf_len) :: InS
logical :: OK, set
integer status, size

OK = .false.
set = .true.
do
    read (aunit,'(a)',advance='NO',iostat=status, size=size) InS
    OK = .not. IS_IOSTAT_END(status)
    if (.not. OK) return
    if (present(InLine)) then
        if (set) then
            InLine = InS(1:size)
            set=.false.
        else
            InLine = InLine //InS(1:size)
        end if
    end if
    if (IS_IOSTAT_EOR(status)) exit
end do
if (present(trimmed) .and. present(InLine)) then
    if (trimmed) InLine = trim(adjustl(InLine))
end if

end function ReadLine

Beispielsweise etwas zu tun mit alle Zeilen in einer Datei mit der Einheit "aunit" tun

 character(LEN=:), allocatable :: InLine

 do while (ReadLine(aunit, InLine))
   [.. something with InLine]
 end do

InformationsquelleAutor wordy

Benutzt habe ich die folgenden. Lassen Sie mich wissen, ob es besser oder schlechter als Ihr.

!::::::::::::::::::::: SUBROUTINE OR FUNCTION :::::::::::::::::::::::::::::::::::::::                                                                                                                                   
!__________________ SUBROUTINE lineread(filno,cargout,ios) __________________________                                                                                                                                   
subroutine lineread(filno,cargout,ios)                                                                                                                                                                                  
Use reallocate,ErrorMsg,SumStr1,ChCount                                                                                                                                                                                 
! this subroutine reads                                                                                                                                                                                                 
! 1. following row in a file except a blank line or the line begins with a !#*                                                                                                                                          
! 2. the part of the string until first !#*-sign is found or to end of string                                                                                                                                           
!                                                                                                                                                                                                                       
! input Arguments:                                                                                                                                                                                                      
! filno (integer)             input file number                                                                                                                                                                         
!                                                                                                                                                                                                                       
! output Arguments:                                                                                                                                                                                                     
! cargout (character)     output chArActer string, converted so that all unecessay spaces/tabs/control characters removed.                                                                                              

implicit none                                                                                                                                                                                                           
integer,intent(in)::filno                                                                                                                                                                                               
character*(*),intent(out)::cargout                                                                                                                                                                                      
integer,intent(out)::ios                                                                                                                                                                                                
integer::nlen=0,i,ip,ich,isp,nsp,size                                                                                                                                                                                   
character*11,parameter::sep='=,;()[]{}*~'                                                                                                                                                                               
character::ch,temp*100                                                                                                                                                                                                  
character,pointer::crad(:)                                                                                                                                                                                              

nullify(crad)                                                                                                                                                                                                           
cargout=''; nlen=0; isp=0; nsp=0; ich=-1; ios=0                                                                                                                                                                         
Do While(ios/=-1) !The eof() isn't standard Fortran.                                                                                                                                                                    
READ(filno,"(A)",ADVANCE='NO',SIZE=size,iostat=ios,ERR=9,END=9)ch ! start reading file                                                                                                                                  
! read(filno,*,iostat=ios,err=9)ch;                                                                                                                                                                                     
    if(size>0.and.ios>=0)then                                                                                                                                                                                           
     ich=iachar(ch)                                                                                                                                                                                                     
    else                                                                                                                                                                                                                
     READ(filno,"(A)",ADVANCE='no',SIZE=size,iostat=ios,EOR=9); if(nlen>0)exit                                                                                                                                          
    end if                                                                                                                                                                                                              
    if(ich<=32)then        ! tab(9) or space(32) character                                                                                                                                                              
        if(nlen>0)then                                                                                                                                                                                                  
     if(isp==2)then                                                                                                                                                                                                       
        isp=0;                                                                                                                                                                                                            
     else                                                                                                                                                                                                                 
        isp=1;                                                                                                                                                                                                            
     end if                                                                                                                                                                                                               
eend if; cycle;                                                                                                                                                                                                         
    elseif(ich==33.or.ich==35.or.ich==38)then !if char is comment !# or continue sign &                                                                                                                                 
     READ(filno,"(A)",ADVANCE='yes',SIZE=size,iostat=ios,EOR=9)ch; if(nlen>0.and.ich/=38)exit;                                                                                                                          
    else                                                                                                                                                                                                                
     ip=scan(ch,sep);                                                                                                                                                                                                   
     if(isp==1.and.ip==0)then; nlen=nlen+1; crad=>reallocate(crad,nlen); nsp=nsp+1; endif                                                                                                                               
     nlen=nlen+1; crad=>reallocate(crad,nlen); crad(nlen)=ch;                                                                                                                                                           
     isp=0; if(ip==1)isp=2;                                                                                                                                                                                             
    end if                                                                                                                                                                                                              
end do                                                                                                                                                                                                                  
9 if(size*ios>0)call ErrorMsg('Met error in reading file in [lineread]',-1)                                                                                                                                             
! ios<0: Indicating an end-of-file or end-of-record condition occurred.                                                                                                                                                 
if(nlen==0)return                                                                                                                                                                                                       
!write(6,'(a,l)')SumStr1(crad),eof(filno)                                                                                                                                                                               
!do i=1,nlen-1; write(6,'(a,$)')crad(i:i); end do; if(nlen>0)write(6,'(a)')crad(i:i)                                                                                                                                    
 cargout=SumStr1(crad)                                                                                                                                                                                                  
 nsp=nsp+1; i=ChCount(SumStr1(crad),' ',',')+1;                                                                                                                                                                         
if(len(cargout)<nlen)then                                                                                                                                                                                               
 call ErrorMsg(SumStr1(crad)//" is too long!",-1)                                                                                                                                                                      
!elseif(i/=nsp.and.nlen>=0)then                                                                                                                                                                                         
! call ErrorMsg(SumStr1(crad)//" has unrecognizable data number!",-1)                                                                                                                                                  
end if                                                                                                                                                                                                                  
end subroutine lineread

InformationsquelleAutor xjcode

0

Ich bin mit Fortran 90, dies zu tun:
```
X = Len_Trim( Seq(I) )           ! length of individual sequence
write(*,'(a<X>)') Seq(I)(1:X)
```
Können Sie einfach erklären, Seq, um eine große Zeichenfolge und dann schneiden Sie es, wie Ihr es schreiben. Ich weiß nicht, wie koscher ist diese Lösung aber es funktioniert sicherlich für meine Zwecke. Ich weiß, dass einige Compiler unterstützen keine "variable format "Ausdrücke", aber es gibt verschiedene workarounds, um die gleiche Sache fast so einfach.

GNU-Fortran-variable, Ausdruck Abhilfe.
- Man kann in der Tat erklären Seq zu werden "groß genug", aber die Frage ist precisly darüber, wie Sie vermeiden, dies zu tun. Auch, warum man nicht einfach write(*, '(A)') trim(Seq(I))?
InformationsquelleAutor Cubby2Zeta

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.