format PE GUI 4.0
entry start

include 'win32ax.inc'

section '.text' code readable executable

  start:
        invoke  GetModuleHandle,0
        mov     [hProcess],eax
        invoke  CreateFile,lpFileName,\
                           GENERIC_READ,\
                           FILE_SHARE_READ,\
                           NULL,\
                           OPEN_EXISTING,\
                           FILE_ATTRIBUTE_NORMAL,\
                           NULL
        cmp     eax,INVALID_HANDLE_VALUE
        je      exit
        mov     [hFile],eax
        invoke  ReadFile,[hFile],\
                         lpBuffer,\
                         [nNumberOfBytesToRead],\
                         lpNumberOfBytesRead,\
                         NULL
        test    eax,eax
        je      .closehandle
        invoke  HeapCreate,HEAP_GENERATE_EXCEPTIONS,\
                           [dwInitialSize],\
                           [dwMaximumSize]
        test    eax,eax
        je      .closehandle
        mov     [hHeap],eax
        invoke  HeapAlloc,[hHeap],\
                          HEAP_ZERO_MEMORY,\
                          [dwInitialSize]
        test    eax,eax
        je      .destroyheap
        mov     [hAllocHeap],eax
        stdcall GetArrayFromFile,lpBuffer,[hAllocHeap],MyArray
        mov     ebx,[MyArray.length]
  .loop:
        cmp     ebx,0
        je      .printresult
        stdcall getArrayElem,MyArray,ebx,value
        movss   xmm0,[value]
        movss   xmm1,[sum]
        addss   xmm1,xmm0
        movss   [sum],xmm1
        dec     ebx
        jmp     .loop
  .printresult:
        fld     dword [sum]
        fstp    qword [sum2]
        invoke  sprintf,buff,fmt,double [sum2]
        invoke  MessageBox,NULL,buff,NULL,MB_OK
  .freeheap:
        invoke  HeapFree,[hHeap],NULL,[hAllocHeap]
  .destroyheap:
        invoke  HeapDestroy,[hHeap]
  .closehandle:
        invoke  CloseHandle,[hFile]
  exit:
        invoke  ExitProcess,0

proc GetArrayFromFile uses ebx ecx edx edi esi,lpbuffer,hMemory,hArray
  locals
    buffer rb 64h
  endl
        mov     ebx,[lpbuffer]
        lea     edx,[buffer]
        mov     edi,[hMemory]
        mov     eax,[hArray]
        mov     [eax+Array.lpbufferArray],edi
        xor     eax,eax
        xor     ecx,ecx
        xor     esi,esi
  .loop1:
        mov     al,byte [ebx]
        cmp     al,2Ch
        je      .delimiter
        cmp     al,20h
        je      .space
        cmp     al,0Dh
        je      .crlf
        cmp     al,00h
        je      .processbuffer
        jmp     .text
  .delimiter:
        inc     ebx
        jmp     .processbuffer
  .crlf:
        add     ebx,2
        jmp     .processbuffer
  .space:
        inc     ebx
        jmp     .loop1
  .text:
        mov     byte [edx],al
        inc     ebx
        inc     edx
        jmp     .loop1
  .processbuffer:
        mov     byte [edx],00h
        cmp     byte [buffer],0 ;Check if empty buffer (end of file)
        je      .exitloop1
        lea     edx,[buffer]
        invoke  atof,edx
        mov     eax,[hMemory]
        fstp    dword [eax+esi*4]
        mov     eax,[hArray]
        add     [eax+Array.length],1
        add     esi,1
        lea     edx,[buffer]
        jmp     .loop1
  .exitloop1:
        ret
endp

proc getArrayElem A,i,v ;OK
     ; Inputs: A - Vector (by Ref)
     ;         i - index
     ; Output: v - Value at A(i) (by Ref)
     push    ebx     ;save registers
     mov     ebx,[A] ;ebx holds vector's structure base address
     mov     ebx,[ebx+(4h*1)] ;ebx holds the array's address
     mov     eax,[i] ;eax holds line coordinate
     dec     eax
     movss   xmm0,[ebx+(4h*eax)] ;move to xmm0 the value at A(i)
     mov     ebx,[v] ;ebx holds address at v
     movss   [ebx],xmm0 ;move value to address that is in ebx
     pop     ebx ;restore saved registers
     ret
endp

section '.bss' readable writeable

  align 16

  struct Array
    length        dd ?
    lpbufferArray dd ?
  ends

  hProcess            dd ?
  hFile               dd ?
  lpNumberOfBytesRead dd ?
  lpBuffer            rb 50h
  hHeap               dd ?
  hAllocHeap          dd ?
  MyArray             Array
  value               dd ?
  sum                 dd ?
  sum2                dq ?
  buff                rb 10h

section '.data' data readable writeable

  nNumberOfBytesToRead dd 200h
  lpFileName           db 'Data.txt',0
  dwInitialSize        dd 2048
  dwMaximumSize        dd 4096
  fmt                  db 'Sum is: %.3f',0

section '.idata' import data readable writeable

  library kernel32,'KERNEL32.DLL',\
          user32,'USER32.DLL',\
          msvcrt,'MSVCRT.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'

  import  msvcrt,\
          atof,'atof',\
          sprintf,'sprintf'
    

1.34, 3.45, 6.78
2.00,-45.1, 1.00
    

1.34, 3.45, 6.78, 2.00,-45.1, 1.00, 4.65 
    

1.34, 3.45, 6.78, 2.00
3.34, 7.45, 4.78, 1.00
1.94, 3.49, 9.79, 7.00
    

local floatdata:DWORD, count:DWORD

mov [count],0
.repeat
   cinvoke fscanf, "%f", addr floatdata
   inc [count]
   mov   edx, [count]
   fld [floatdata]
   fstp [floatarraydata + edx*4]
.until eax = 0 | eax = EOF ;don't know what the value is for EOF.    

@ctl3d32, you can just use SQLLite to keep records.

Recently I tend to use binary file formats, as more asm-adequate. This simple transition can save you tons of code lines and to speed up the program (depending on the size of the files processed).

At the same time, using binary files makes them hard to be manually edited.
So, I though about some common binary data format, that to be easy for human reading and editing (with any hex editor, or with very simple specialized editor) and in the same time to allow natural machine processing.
I don't have solution for such format (or even suggestion) but wrote this just as a ground for meditation.

madmatt: You forgot to include space in your input format string. Should be " %f", in order to skip blanks between numbers (or is this done by default? I don't think so).