Forum strony www.multipasko.pl [Regulamin]


Dodaj wpis w tym temacie
Spis tematów
Login:

Hasło:
Strona: 1 2 ... 550 551 552 553 554 555
Wyślij wiadomość do admina

Przewiń wpisy ↓

moje ... oprogramowanie

2025-03-19 (23:06)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 335
[ CZCIONKA MONOSPACE ]

A...... co do problemu.....

przy wyborze 4*po 1 z 80 liczb
czas znalezienia 4* po jednej żądanej liczbie
przy procesie na 4 wątki
--> nie jest mierzalny w milisekundach

raptem 3 milisekundy to czas głównie wypisu
jak wcześniej na wstawionym powyżej
i poniżej
obrazku

--- wpis edytowano 2025-03-19 23:07 ---

2025-03-20 (08:54)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 357
[ CZCIONKA MONOSPACE ]

kleszek
Jeśli będziesz miał jakies pytania do AI,
mogę je zadać w Twoim imieniu.
Jeszcze przez kilka dni mam dostęp "plus" do tej platformy.

Poproszę zatem abyś zadał pytanie,
dotyczące multithreading delphi object pascal.

Mianowicie pytanie brzmi :

Podaj przykład procedury obliczeń z użyciem
pętli Loop ,z zastosowaniem Multithreadingu
w delphi object pascal,
dla 32 wątków jednocześnie wykonujących proces obliczeń.
Przykład procedury obliczeń , której wynik jest zawsze ten sam,
a czas obliczeń jest różny w zależności od ilości rdzeni procesora.
Przykładowa procedura działać musi niezależnie od ilości rdzeni.

no i ciekaw jestem ..co podpowie AI
2025-03-20 (09:10)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 361
[ CZCIONKA MONOSPACE ]

Instrukcja iteracyjna
jest to każda pętla (while, do..while, for)

EDIT:
Czyli instrukcja powtarzania pewnego zestawu poleceń.
Nazwa wzięła się od łacińskiego słowa iteratio,
itero ("powtarzanie" w wolnym tłumaczeniu).
Iteracja oznacza także pojedyncze wykonanie pętli.
---------------------------------------------------


A jak odpowie AI to skompilujemy i
zobaczymy co podpowiedziała

--------------------------------------------------
A jak odpowie to
zadaj podobne pytanie ........



Mianowicie 2-pytanie brzmi :

Podaj przykład procedury obliczeń z użyciem kilku
instrukcji iteracyjnych ,z zastosowaniem Multithreadingu
w delphi object pascal,
dla 32 wątków jednocześnie wykonujących proces obliczeń.
Przykład procedury obliczeń , której wynik jest zawsze ten sam,
a czas obliczeń jest różny w zależności od ilości rdzeni procesora.
Przykładowa procedura działać musi niezależnie od ilości rdzeni.

pozdrawiam

--- wpis edytowano 2025-03-20 09:14 ---

2025-03-20 (09:41)

status kleszek
Data rejestracji: 2006-05-27
Ilość postów: 4979

2047
wpis nr 1 558 368
[ CZCIONKA MONOSPACE ]

777ch, zrobię to jak wrócę po pracy do domu. Około godziny 14-15
2025-03-20 (12:31)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 391
[ CZCIONKA MONOSPACE ]

Tworzymy 32 wątki za pomocą klasy TThread.
Każdy wątek wykonuje iteracyjne obliczenia (np. sumowanie wartości z określonego zakresu).
Synchronizujemy dostęp do wspólnej zmiennej GlobalSum przy użyciu TInterlocked.Add.
Czekamy na zakończenie wszystkich wątków.
Mierzymy czas wykonania dla różnych konfiguracji procesora.

program MultiThreadedComputation;

uses
System.SysUtils, System.Classes, System.SyncObjs, System.Diagnostics;

const
THREAD_COUNT = 32;
ITERATIONS = 1000000; // Ilość iteracji w każdym wątku

var
GlobalSum: Int64; // Globalna zmienna przechowująca wynik końcowy
Threads: array [0..THREAD_COUNT - 1] of TThread;
Stopwatch: TStopwatch;

type
TComputeThread = class(TThread)
private
FThreadID: Integer;
protected
procedure Execute; override;
public
constructor Create(ThreadID: Integer);
end;

constructor TComputeThread.Create(ThreadID: Integer);
begin
inherited Create(False); // Uruchamiamy wątek natychmiast
FreeOnTerminate := False; // Nie usuwamy automatycznie
FThreadID := ThreadID;
end;

procedure TComputeThread.Execute;
var
LocalSum: Int64;
I: Integer;
begin
LocalSum := 0;
for I := 1 to ITERATIONS do
begin
LocalSum := LocalSum + (I mod 10); // Przykładowe obliczenia
end;

TInterlocked.Add(GlobalSum, LocalSum); // Atomowe dodanie wyniku
end;

procedure RunComputation;
var
I: Integer;
begin
GlobalSum := 0; // Resetujemy globalny wynik
Stopwatch := TStopwatch.StartNew;

// Tworzymy i uruchamiamy wątki
for I := 0 to THREAD_COUNT - 1 do
Threads[I] := TComputeThread.Create(I);

// Czekamy na zakończenie wszystkich wątków
for I := 0 to THREAD_COUNT - 1 do
begin
Threads[I].WaitFor;
Threads[I].Free;
end;

Stopwatch.Stop;
Writeln('Wynik obliczeń: ', GlobalSum);
Writeln('Czas wykonania (ms): ', Stopwatch.ElapsedMilliseconds);
end;

begin
try
Writeln('Rozpoczynamy wielowątkowe obliczenia...');
RunComputation;
Writeln('Koniec obliczeń.');
except
on E: Exception do
Writeln('Błąd: ', E.Message);
end;
Readln;
end.

Tworzymy 32 wątki – TComputeThread, każdy wykonuje obliczenia w Execute.
Każdy wątek iteruje ITERATIONS = 1 000 000 razy, dodając wartości do LocalSum.
TInterlocked.Add zapewnia, że operacja dodawania do GlobalSum jest atomowa (unikamy problemów z równoczesnym dostępem do pamięci).
Stopwatch mierzy czas wykonania i wynik jest wyświetlany.
Właściwości tej implementacji:
✅ Wynik zawsze ten sam – suma z 32 wątków jest zawsze identyczna.
✅ Czas zależny od CPU – na wielordzeniowych CPU wykonuje się szybciej, ale działa również na jednordzeniowych procesorach.
✅ Zastosowanie TInterlocked – zapewnia synchronizację wątków bez potrzeby stosowania krytycznych sekcji (TMonitor, TCriticalSection).
✅ Zgodność z różnymi wersjami Delphi – działa w Delphi XE i nowszych.
2025-03-20 (13:53)

status kleszek
Data rejestracji: 2006-05-27
Ilość postów: 4979

2047
wpis nr 1 558 403
[ CZCIONKA MONOSPACE ]

Pytanie

multithreading delphi object pascal

Podaj przykład procedury obliczeń z użyciem
pętli Loop ,z zastosowaniem Multithreadingu
w delphi object pascal,
dla 32 wątków jednocześnie wykonujących proces obliczeń.
Przykład procedury obliczeń , której wynik jest zawsze ten sam,
a czas obliczeń jest różny w zależności od ilości rdzeni procesora.
Przykładowa procedura działać musi niezależnie od ilości rdzeni.

Odpowiedź

Poniżej przedstawiam przykładowy kod w Delphi (Object Pascal), który tworzy 32 wątki – każdy z nich wykonuje pętlę obliczeniową (w tym przykładzie sumuje funkcję sinus w określonym zakresie). Wynik całkowity jest deterministyczny (przy tych samych ustawieniach ITER_COUNT), a czas wykonania zależy od liczby rdzeni procesora, ponieważ wątki będą planowane przez system operacyjny niezależnie od dostępnych rdzeni.

procedure MultiThreadedCalculation;
const
THREAD_COUNT = 32; // liczba wątków
ITER_COUNT = 1000000; // liczba iteracji w każdym wątku (można zwiększyć, aby obciążenie było większe)
var
Threads: array of TThread;
Results: array of Double;
i: Integer;
GlobalResult: Double;
begin
SetLength(Threads, THREAD_COUNT);
SetLength(Results, THREAD_COUNT);

// Inicjalizacja wyników dla każdego wątku
for i := 0 to THREAD_COUNT - 1 do
Results[i] := 0.0;

// Tworzenie i uruchamianie wątków
for i := 0 to THREAD_COUNT - 1 do
begin
// Używamy lokalnej zmiennej 'idx', aby zapewnić poprawne przekazanie numeru wątku
var idx: Integer;
idx := i;
Threads[i] := TThread.CreateAnonymousThread(
procedure
var
j: Integer;
LocalResult: Double;
begin
LocalResult := 0.0;
// Przykładowe obliczenia – suma wartości Sin(j)
for j := 1 to ITER_COUNT do
LocalResult := LocalResult + Sin(j);
Results[idx] := LocalResult;
end
);
Threads[i].Start;
end;

// Oczekiwanie na zakończenie wszystkich wątków
for i := 0 to THREAD_COUNT - 1 do
Threads[i].WaitFor;

// Sumowanie wyników z poszczególnych wątków
GlobalResult := 0.0;
for i := 0 to THREAD_COUNT - 1 do
GlobalResult := GlobalResult + Results[i];

// Wyświetlenie wyniku
WriteLn(Format('Wynik obliczeń: %f', [GlobalResult]));
end;
Kilka uwag:
Deterministyczność: Obliczenia (suma sinusa) są deterministyczne – przy tym samym ITER_COUNT wynik będzie zawsze taki sam.
Wielowątkowość: Nawet jeśli komputer ma mniej niż 32 rdzenie, procedura utworzy 32 wątki. System operacyjny sam rozplanuje ich wykonanie na dostępnych rdzeniach, co wpłynie na czas obliczeń.
Lokalna zmienna 'idx': Dzięki użyciu lokalnej zmiennej 'idx' unikamy problemu zamknięcia (closure) w anonimowej procedurze, co gwarantuje, że każdy wątek zapisze wynik do właściwego elementu tablicy.
Przykładowa procedura działa niezależnie od ilości rdzeni – niezależnie od sprzętu, zawsze zostanie uruchomionych 32 wątki, a czas wykonania będzie odzwierciedlał możliwości obliczeniowe komputera.
2025-03-20 (13:57)

status kleszek
Data rejestracji: 2006-05-27
Ilość postów: 4979

2047
wpis nr 1 558 406
[ CZCIONKA MONOSPACE ]

Pytanie 2

Podaj przykład procedury obliczeń z użyciem kilku
instrukcji iteracyjnych ,z zastosowaniem Multithreadingu
w delphi object pascal,
dla 32 wątków jednocześnie wykonujących proces obliczeń.
Przykład procedury obliczeń , której wynik jest zawsze ten sam,
a czas obliczeń jest różny w zależności od ilości rdzeni procesora.
Przykładowa procedura działać musi niezależnie od ilości rdzeni.

Odpowiedź

Poniżej przykład procedury w Delphi (Object Pascal), w której dla 32 wątków równolegle wykonywane są dwa zestawy iteracyjnych obliczeń. Każdy wątek wykonuje:

Pierwszą pętlę – sumuje iloczyn sinusa i cosinusa kolejnych liczb,
Drugą pętlę – dodaje logarytm (ln) z wartości (j + 1).
Wynik końcowy jest sumą wyników wszystkich wątków. Dzięki temu, mimo że każdy wątek wykonuje te same obliczenia, czas ich wykonania zależy od liczby rdzeni procesora (system sam rozdziela wątki na dostępne rdzenie), a procedura działa niezależnie od ich liczby.

procedure MultiThreadedCalculation;
const
THREAD_COUNT = 32; // liczba wątków
ITER1_COUNT = 100000; // liczba iteracji w pierwszej pętli
ITER2_COUNT = 50000; // liczba iteracji w drugiej pętli
var
Threads: array of TThread;
Results: array of Double;
i: Integer;
GlobalResult: Double;
begin
SetLength(Threads, THREAD_COUNT);
SetLength(Results, THREAD_COUNT);
for i := 0 to THREAD_COUNT - 1 do
Results[i] := 0.0;

// Tworzymy i uruchamiamy 32 wątki
for i := 0 to THREAD_COUNT - 1 do
begin
var idx: Integer := i; // zmienna pomocnicza, aby uniknąć problemu zamknięcia (closure)
Threads[i] := TThread.CreateAnonymousThread(
procedure
var
j: Integer;
LocalResult: Double;
begin
LocalResult := 0.0;
// Pierwsza pętla iteracyjna – obliczenia z użyciem sinusa i cosinusa
for j := 1 to ITER1_COUNT do
LocalResult := LocalResult + Sin(j) * Cos(j);
// Druga pętla iteracyjna – obliczenia z użyciem logarytmu naturalnego
for j := 1 to ITER2_COUNT do
LocalResult := LocalResult + Ln(j + 1);
// Zapis wyniku dla danego wątku
Results[idx] := LocalResult;
end
);
Threads[i].Start;
end;

// Oczekiwanie na zakończenie wszystkich wątków
for i := 0 to THREAD_COUNT - 1 do
Threads[i].WaitFor;

// Sumujemy wyniki z poszczególnych wątków
GlobalResult := 0.0;
for i := 0 to THREAD_COUNT - 1 do
GlobalResult := GlobalResult + Results[i];

// Wyświetlenie końcowego wyniku
WriteLn(Format('Wynik obliczeń: %f', [GlobalResult]));
end;
Uwagi:
Deterministyczność: Obliczenia w każdej pętli są deterministyczne, więc dla ustalonych stałych ITER1_COUNT i ITER2_COUNT wynik końcowy będzie zawsze taki sam.
Wielowątkowość: Nawet jeśli komputer ma mniej niż 32 rdzenie, procedura utworzy 32 wątki – system operacyjny rozplanuje ich wykonanie na dostępnych rdzeniach, co wpływa na czas obliczeń.
Niezależność od liczby rdzeni: Procedura działa zawsze tak samo, niezależnie od sprzętowych możliwości, a czas wykonania obliczeń zależy jedynie od dostępnych rdzeni procesora.
Ten przykład ilustruje, jak wykorzystać multithreading wraz z kilkoma instrukcjami iteracyjnymi w Delphi, aby osiągnąć deterministyczne wyniki przy zmiennym czasie wykonania zależnym od konfiguracji sprzętowej.
2025-03-20 (14:13)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 407
[ CZCIONKA MONOSPACE ]

To samo pytanie i różne odpowiedzi.
Kleszek zadaj to samo jeszcze raz i co otrzymasz ?
2025-03-20 (14:20)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 408
[ CZCIONKA MONOSPACE ]

Jest jeszcze problem oceny tego co dostajesz, bo w każdej opowiedzi mogą być zawarte bzdury,
wyrwane z kontekstu fragmenty cudzych kodów, albo niepasujące do używanej wersji delphi a czasem zupełnie wymyślone
Kolejne pytanie czy czat darmowy czy płatny.
Przecież ostrzegają na początku, że czat może popełniać błędy

A co zwerifikujesz, przecież to nie jest forum programistów.
2025-03-20 (14:23)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 410
[ CZCIONKA MONOSPACE ]

Pytanie dla Copilota:
Podaj przykład procedury obliczeń z użyciem kilku instrukcji iteracyjnych ,z zastosowaniem Multithreadingu w delphi object pascal, dla 32 wątków jednocześnie wykonujących proces obliczeń. Przykład procedury obliczeń , której wynik jest zawsze ten sam, a czas obliczeń jest różny w zależności od ilości rdzeni procesora. Przykładowa procedura działać musi niezależnie od ilości rdzeni.
=======================================================
Oto przykład procedury w Delphi Object Pascal, która wykorzystuje 32 wątki do obliczeń. Wynik procedury pozostaje taki sam, niezależnie od liczby rdzeni procesora, ale czas wykonania zależy od dostępnych zasobów sprzętowych. Procedura opiera się na technikach wielowątkowości z użyciem klasy TTask z System.Threading:

delphi
program MultiThreadExample;

uses
System.SysUtils, System.Threading;

const
ThreadCount = 32;

function ComputeTask(Index: Integer): Integer;
var
Sum, I: Integer;
begin
Sum := 0;
for I := 1 to 100000000 do
Sum := (Sum + Index) mod 1000; // Prosta iteracyjna operacja obliczeniowa
Result := Sum;
end;

procedure RunMultiThreadedComputation;
var
Results: array[0..ThreadCount - 1] of Integer;
Tasks: array[0..ThreadCount - 1] of ITask;
I: Integer;
FinalSum: Integer;
begin
// Tworzymy i uruchamiamy 32 wątki
for I := 0 to ThreadCount - 1 do
begin
Tasks[I] := TTask.Run(
procedure
begin
Results[I] := ComputeTask(I);
end
);
end;

// Oczekiwanie na zakończenie wszystkich wątków
TTask.WaitForAll(Tasks);

// Zbieranie wyników
FinalSum := 0;
for I := 0 to ThreadCount - 1 do
Inc(FinalSum, Results[I]);

Writeln('Final Sum: ', FinalSum);
end;

begin
try
Writeln('Starting multi-threaded computation...');
RunMultiThreadedComputation;
Writeln('Computation complete.');
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
end.
Wyjaśnienie:
Iteracyjne obliczenia: Funkcja ComputeTask wykonuje iteracje, które realizują proste obliczenia. W tym przykładzie, obliczenia zawsze zwracają przewidywalny wynik dla tej samej liczby Index.

Wielowątkowość: TTask pozwala na równoległe wykonywanie kodu w niezależnych wątkach.

Niezależność od liczby rdzeni: Program uruchamia 32 wątki, niezależnie od liczby rdzeni procesora. Czas wykonania będzie różny w zależności od liczby rdzeni, ale wynik pozostanie spójny.

Synchronizacja: TTask.WaitForAll zapewnia, że wszystkie wątki zakończą swoje działanie przed kontynuacją programu.
2025-03-20 (14:36)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 412
[ CZCIONKA MONOSPACE ]

MultiTest

No to będzie co sprawdzać na moich 16-rdzeniach.
Ale jak to czy tamto skompiluję.
Wydaje mi się jednak ,że bardziej skomplikowane
procesy obliczeń nie uzyskają jakiejś spektakularnej
różnicy w czasie.

Jedną z kompilacji ,-->procedura z netu
skompilowałem dla 32b a druga dla 64b

i jest różnica obliczeń na korzyść 64

oto obrazkowe porównanie



--- wpis edytowano 2025-03-20 14:36 ---

2025-03-20 (14:43)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 416
[ CZCIONKA MONOSPACE ]

powyżej to kompilacje tego procesu:


unit Unit1;

interface

uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, system.threading, math;



type
TForm1 = class(TForm)

Memo1: TMemo;
Button1: TButton;
procedure Button1Click(Sender: TObject);
{ TMyThread is the class that will handle our background work }

private
{ Private declarations }
public
{ Public declarations }

end;





podziałLiczby= array[0..9] of integer;
zakresy= array[1..4] of record
dół, góra: int64
end;
wynik= array[0..9] of record
ileCyfr: integer;
liczba: int64
end;
TYPE

MyThread = class(TThread)
end;

{$R *.dfm}

var
Form1: TForm1;
hczas,hgodz,hmin,hsec,hmilsec:string;
ilerdzeni:integer;




implementation



function podzielNaZakresy(a,b: int64): zakresy;
//dzieli zakres pętli for dla rozłożenia na cztery rdzenie procesora
var
i, iloraz: int64;
wynik: zakresy;
begin
iloraz:= (b-a+1)div 4;
for i := 1 to 4 do
begin
wynik[i].dół:= (i-1)*iloraz+a;
if i<4
then
wynik[i].góra:= (i-1)*iloraz+a+iloraz-1
else
wynik[i].góra:= b;
end;
result:=wynik
end;

function rozłóżLiczbę(i: int64):podziałLiczby;
//liczy wystąpienia cyfr w liczbie
var
k,c : integer;
s: string;
temp: podziałLiczby;
begin
for k := 0 to 9 do
temp[k]:= 0;
s:=IntToStr(i);
for k:= 0 to 9 do
begin
c:= StrToInt(s[k+1]);
temp[c]:= temp[c]+1;
end;
result:= temp;
end;


procedure TForm1.Button1Click(Sender: TObject);
var
maks: wynik;
wynikiRdzeni: array[1..4] of wynik;
zakresyRdzeni: zakresy;
tasks: array of ITask;
i,k: int64;
hours, minutes, seconds, millisec: word;
start,koniec,timeDiff: tdatetime;
begin
//ilerdzeni:=MyThread.ProcessorCount.Size;
button1.Caption:='Liczba rdzeni: '+inttostr(MyThread.ProcessorCount.Size);
start:= now;
for i:=0 to 9 do
maks[i].ileCyfr:= 0;
for i := 1 to 4 do
for k := 0 to 9 do
wynikiRdzeni[i,k].ileCyfr:=0;
Setlength(tasks ,4);
zakresyRdzeni:= podzielNaZakresy(1000000000,1800000000);

tasks[0]:= TTask.Create (procedure ()
var
temp: podziałLiczby;
i,k: int64;
begin
For i:= zakresyRdzeni[1].dół to zakresyRdzeni[1].góra do
begin
if sqr(round(sqrt(i))) = i
then
begin
temp:= rozłóżLiczbę(i);
for k:= 0 to 9 do
if temp[k]> wynikiRdzeni[1,k].ileCyfr
then
begin
wynikiRdzeni[1,k].ileCyfr:= temp[k];
wynikiRdzeni[1,k].liczba:= i
end;
end;
end
end);
tasks[0].Start;

tasks[1]:= TTask.Create (procedure ()
var
temp: podziałLiczby;
i,k: int64;
begin
For i:= zakresyRdzeni[2].dół to zakresyRdzeni[2].góra do
begin
if sqr(round(sqrt(i))) = i
then
begin
temp:= rozłóżLiczbę(i);
for k:= 0 to 9 do
if temp[k]> wynikiRdzeni[2,k].ileCyfr
then
begin
wynikiRdzeni[2,k].ileCyfr:= temp[k];
wynikiRdzeni[2,k].liczba:= i
end;
end;
end
end);
tasks[1].Start;

tasks[2]:= TTask.Create (procedure ()
var
temp: podziałLiczby;
i,k: int64;
begin
For i:= zakresyRdzeni[3].dół to zakresyRdzeni[3].góra do
begin
if sqr(round(sqrt(i))) = i
then
begin
temp:= rozłóżLiczbę(i);
for k:= 0 to 9 do
if temp[k]> wynikiRdzeni[3,k].ileCyfr
then
begin
wynikiRdzeni[3,k].ileCyfr:= temp[k];
wynikiRdzeni[3,k].liczba:= i
end;
end;
end
end);
tasks[2].Start;

tasks[3]:= TTask.Create (procedure ()
var
temp: podziałLiczby;
i,k: int64;
begin
For i:= zakresyRdzeni[4].dół to zakresyRdzeni[4].góra do
begin
if sqr(round(sqrt(i))) = i
then
begin
temp:= rozłóżLiczbę(i);
for k:= 0 to 9 do
if temp[k]> wynikiRdzeni[4,k].ileCyfr
then
begin
wynikiRdzeni[4,k].ileCyfr:= temp[k];
wynikiRdzeni[4,k].liczba:= i
end;
end;
end
end);
tasks[3].Start;

TTask.WaitForAll(tasks);

//zbieramy dane z wątków razem
for i:= 0 to 9 do
for k:=1 to 4 do
if wynikiRdzeni[k,i].ileCyfr>maks[i].ileCyfr
then
begin
maks[i].ileCyfr:= wynikiRdzeni[k,i].ileCyfr;
maks[i].liczba:= wynikiRdzeni[k,i].liczba
end;

koniec:= now;
timeDiff:= koniec - start;
DecodeTime(timeDiff, hours, minutes, seconds, millisec);
memo1.Lines.Add('godziny='+IntToStr(hours));
memo1.Lines.Add('minuty='+IntToStr(minutes));
memo1.Lines.Add('sekundy='+IntToStr(seconds));
memo1.Lines.Add('milisekundy='+IntToStr(millisec));

if hours=0 then
hgodz:='00'
else
if (hours<10)and(hours>0) then
hgodz:= '0'+IntToStr(hours)
else
if hours>=10 then
hgodz:= IntToStr(hours);


if minutes=0 then
hmin:='00'
else
if (minutes<10)and(minutes>0) then
hmin:= '0'+IntToStr(minutes)
else
if minutes>=10 then
hmin:= IntToStr(minutes);

if seconds=0 then
hsec:='00'
else
if (seconds<10)and(seconds>0) then
hsec:= '0'+IntToStr(seconds)
else
if seconds>=10 then
hsec:= IntToStr(seconds);

if millisec=0 then
hmilsec:='000'
else
if (millisec<10)and(millisec>0) then
hmilsec:= '00'+IntToStr(millisec)
else
if (millisec<100)and(millisec>=10) then
hmilsec:= '0'+IntToStr(millisec)
else
if millisec>=100 then
hmilsec:= IntToStr(millisec);
memo1.Lines.Add('');
memo1.Lines.Add('elapsed time: '+ hgodz+' '+hmin+' '+hsec+' '+hmilsec);
memo1.Lines.Add('');
for k:= 0 to 9 do
if maks[k].ileCyfr > 0
then
memo1.Lines.Add('najwięcej cyfr dla '+IntToStr(k)+' wynosi '+
IntToStr(maks[k].ileCyfr)+' dla '+IntToStr(maks[k].liczba))
end;


end.


----------------------------------------
To opracowanie z jakiejś strony w necie
z drobną modyfikacją.
2025-03-20 (14:45)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 417
[ CZCIONKA MONOSPACE ]

64 bitowa kompilacja, większe możliwości, większa wydajność.
2025-03-20 (14:51)

status MultiTest
Data rejestracji: 2020-08-05
Ilość postów: 5924

16235
wpis nr 1 558 418
[ CZCIONKA MONOSPACE ]

ale, jeśli szukać efektywności to nie koniecznie pokrycie może być jedynym środkiem do celu, przecież może być tak, że pokrycie pokaże że jeszcze dużo brakuje, nawet gdy rzeczywista gwarancja będzie 100 %

--- wpis edytowano 2025-03-20 14:52 ---

2025-03-20 (15:14)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 419
[ CZCIONKA MONOSPACE ]

wpis nr 1 558 406

Tam jest coś nie tak
2025-03-20 (15:16)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 420
[ CZCIONKA MONOSPACE ]

MultiTest

Ale czasem wychodzi ,
że inne procedury oraz kompilacje 32b są szybsze.
Na razie nie wiem dlaczego tak jest.
2025-03-20 (15:26)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 422
[ CZCIONKA MONOSPACE ]

MultiTest

ale, jeśli szukać efektywności to nie koniecznie pokrycie może być jedynym środkiem do celu, przecież może być tak, że pokrycie pokaże że jeszcze dużo brakuje, nawet gdy rzeczywista gwarancja będzie 100 %

albo gwarancja wynosi 100% albo nie wynosi 100%
oczywiście .... można pokusić się o stwierdzenie
że tak i tak zbudowany rozpis zdecydowanie daje WYNIK= cel= x/y
ale tak jak wspomniałem ,gwarancja 100% to termin konkretny.
2025-03-20 (15:29)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 423
[ CZCIONKA MONOSPACE ]

Poproszę o inne przykłady
ale nie konsolowe ,
i sprawdzone [Multitest]
jeśli można ,
bo jak na razie te przykłady odrobinę mało ciekawe.
2025-03-20 (17:07)

status 777ch
Data rejestracji: 2005-11-07
Ilość postów: 22656

1386
wpis nr 1 558 430
[ CZCIONKA MONOSPACE ]

AI chat „wie”..tyle ile
jest jej udostępnione ,
nie potrafi myśleć jak człowiek,
składa jedynie
bardziej lub mniej „nieudolnie”
—> „kolaże” z „dostępnych zasobów” .
Tak to widzę.
2025-03-20 (17:27)

status kleszek
Data rejestracji: 2006-05-27
Ilość postów: 4979

2047
wpis nr 1 558 432
[ CZCIONKA MONOSPACE ]

777ch, chat to nie człowiek Jak zadasz mu pytanie, tak na nie odpowie. Im bardziej precyzyjne pytanie, tym lepsza odpowiedź. Często prosząc chat o napisanie jakiegoś makra w Vba otrzymywałem na początku makro niedziałające. Błędy typu brak użytej w makrze funcji itd. Po zgłoszeniu dla chata danego błędu, następuje błyskawiczna "naprawa" makra. Zdarzało mi się, że musiałem zgłaszać kilka razy błędy w jednym makrze, ale zawsze na końcu otrzymywałem to o co prosiłem. Chat to droga na skróty, droga czasem wyboista ale prowadząca do celu. Czasem trzeba chat-a odpowiednio prowadzić "na smyczy" aby uzyskać zamierzony cel
| Dodaj wpis w tym temacie | Spis tematów | Wyniki lottoStrona: 1 2 ... 550 551 552 553 554 555
Wyślij wiadomość do admina