Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 87
0
SparseMatrix<double> mat(rows,cols);
for (int k=0; k<mat.outerSize(); ++k)
for (SparseMatrix<double>::InnerIterator it(mat,k); it; ++it)
{
it.value();
it.row(); // row index
it.col(); // col index (here it is equal to k)
it.index(); // inner index, here it is equal to it.row()
}Random access to the elements of a sparse object can be done through the coeffRef(i,j) function. However, this function involves a quite expensive binary search. In most cases, one only wants to iterate over the non-zeros elements. This is achieved by a standard loop over the outer dimension, and then by iterating over the non-zeros of the current inner vector via an InnerIterator. Thus, the non-zero entries have to be visited in the same order than the storage order.
CHayT,
03 Сентября 2025
0
https://github.com/PlummersSoftwareLLC/Primes/blob/drag-race/PrimeChapel/solution_1/primes.chpl#L92Царские анроллы.
CHayT,
06 Сентября 2022
−1
https://github.com/tejdnk-2019-ShortNotes/
CHayT,
14 Марта 2022
0
%% Note: set and unset are not thread-safe.
-spec set(key(), value()) -> ok.
set(Key, Value) ->
case ets:lookup(?status_tab, Key) of
[{_, {set, _OldValue}}] ->
ets:insert(?status_tab, {Key, {set, Value}});
[{_, {unset, Pid}}] ->
MRef = monitor(process, Pid),
Pid ! {set, Value},
receive
{'DOWN', MRef, _, _, _} -> ok
end;
[] ->
case ets:insert_new(?status_tab, {Key, {set, Value}}) of
true ->
ok;
false ->
set(Key, Value)
end
end,
ok.
-spec unset(key()) -> ok.
unset(Key) ->
case ets:lookup(?status_tab, Key) of
[{_, {set, _OldValue}}] -> ets:delete(?status_tab, Key);
_ -> ok
end,
ok.
-spec read(key()) -> value().
read(Key) ->
case read_or_wait(Key) of
{set, Value} ->
Value;
{wait, MRef} ->
receive
{'DOWN', MRef, _, _, {cvar_set, Value}} ->
Value;
{'DOWN', MRef, _, _, noproc} ->
read(Key)
end
end.
-spec read_or_wait(key()) -> {set, value()} | {wait, reference()}.
read_or_wait(Key) ->
case ets:lookup(?status_tab, Key) of
[] ->
{Pid, MRef} = spawn_monitor(?MODULE, waker_entrypoint, [Key, self()]),
receive
{Pid, proceed} ->
{wait, MRef};
{'DOWN', MRef, _, _, Reason} ->
cvar_retry = Reason,
read_or_wait(Key)
end;
[{_, {set, Val}}] ->
{set, Val};
[{_, {unset, Pid}}] ->
{wait, monitor(process, Pid)}
end.
-spec waker_entrypoint(key(), pid()) -> no_return().
waker_entrypoint(Key, Parent) ->
case ets_insert_new({Key, {unset, self()}}) of
false ->
exit(cvar_retry);
true ->
Parent ! {self(), proceed},
receive
{set, Value} ->
ets_insert({Key, {set, Value}}),
exit({cvar_set, Value})
end
end.
CHayT,
08 Февраля 2022
+2
https://github.com/golded-plus/golded-plus/blob/master/golded3/gccfgg0.cpp#L162
CHayT,
25 Января 2022
+3
#!/usr/bin/env escript
-mode(compile).
main(["-p"|Filenames]) ->
put(pretend, true),
main(Filenames);
main(Filenames) ->
case get(pretend) of
true -> ok;
_ -> put(pretend, false)
end,
Albums = lists:filtermap(fun parse_name/1, Filenames),
lists:foreach(fun process_album/1, Albums).
process_album({Zip, Artist, Album}) ->
Dir = filename:absname(filename:join(Artist, Album)),
case filelib:wildcard(Dir ++ "/cover.*") of
[] ->
io:format("Will create ~p~n", [Dir]),
get(pretend) orelse do_process_album(Dir, Zip, Album);
_ ->
io:format("Ignoring ~p : ~p~n", [Artist, Album])
end.
do_process_album(Dir, Zip, Album) ->
ok = filelib:ensure_dir(Dir ++ "/fake"),
0 = exec(Dir, "/usr/bin/unzip", [Zip, "-d", Dir]),
postprocess(Album, Dir).
postprocess(Album, Dir) ->
Files = filelib:wildcard(Dir ++ "/*-*[0-9]*.flac"),
lists:foreach(fun(I) -> rename_flac(Album, I) end, Files).
rename_flac(Album, OldFile) ->
Dir = filename:dirname(OldFile),
OldName = filename:basename(OldFile),
Options = [{capture, all_but_first, list}],
{ok, RE} = re:compile(Album ++ " - ([0-9]+.*\\.flac)", [unicode]),
case re:run(OldName, RE, Options) of
{match, [NewName]} ->
io:format("New name: ~p~n", [NewName]),
NewFile = filename:join(Dir, NewName),
ok = file:rename(OldFile, NewFile);
nomatch ->
ok
end.
parse_name(Filename) ->
Opts = [{capture, ['band', album], list}],
case re:run(filename:basename(Filename), "(?<band>[^-]+) - (?<album>.*)\\.zip", Opts) of
{match, [Band, Album]} ->
{true, {filename:absname(Filename), Band, Album}};
nomatch ->
false
end.
-spec exec(file:filename(), file:filename(), [string() | binary()]) -> integer().
exec(Dir, CMD, Args) ->
Port = open_port( {spawn_executable, CMD}
, [ exit_status
, binary
, stderr_to_stdout
, {args, Args}
, {cd, Dir}
, {line, 300}
]
),
collect_port_output(Port, filename:basename(CMD)).
-spec collect_port_output(port(), string()) -> integer().
collect_port_output(Port, CMD) ->
receive
{Port, {data, {_, Data}}} ->
io:format("~s: ~s~n", [CMD, Data]),
collect_port_output(Port, CMD);
{Port, {exit_status, ExitStatus}} ->
ExitStatus
end.
CHayT,
08 Января 2022
+2
Ltac2 make_match fields :=
destruct x;
iter (fun a => focus 1 1 (fun () =>
let a := a ()
in refine (fun () => '((w_rep $a) _)))
) fields.Итерация по конструкторам индуктивного типа данных.
CHayT,
03 Декабря 2021
+1
(** Set of all possible interleaving of two traces is a trace
ensemble. As we later prove in [interleaving_to_permutation], this
definition is dual to [Permutation]. *)
Inductive Interleaving : list TE -> list TE -> TraceEnsemble :=
| ilv_cons_l : forall te t1 t2 t,
Interleaving t1 t2 t ->
Interleaving (te :: t1) t2 (te :: t)
| ilv_cons_r : forall te t1 t2 t,
Interleaving t1 t2 t ->
Interleaving t1 (te :: t2) (te :: t)
| ilv_nil : Interleaving [] [] [].
Попытка оптимизации:
(* Left-biased version of [Interleaving] that doesn't make
distinction between schedulings of commuting elements: *)
Inductive UniqueInterleaving : list TE -> list TE -> TraceEnsemble :=
| uilv_cons_l : forall l t1 t2 t,
UniqueInterleaving t1 t2 t ->
UniqueInterleaving (l :: t1) t2 (l :: t)
| uilv_cons_r1 : forall l r t1 t2 t,
~trace_elems_commute l r ->
UniqueInterleaving (l :: t1) t2 (l :: t) ->
UniqueInterleaving (l :: t1) (r :: t2) (r :: l :: t)
| uilv_cons_r2 : forall r1 r2 t1 t2 t,
UniqueInterleaving t1 (r1 :: t2) (r1 :: t) ->
UniqueInterleaving t1 (r2 :: r1 :: t2) (r2 :: r1 :: t)
| uilv_nil : forall t, UniqueInterleaving [] t t.Сложный говнокод. Почему вторая "оптимизированная" версия работает хуже первой?
CHayT,
01 Ноября 2021
+1
waiting_for_data(info, {Driver,Socket,Data},
#state{socket=Socket, driver=Driver, driver_mod=DriverMod, peer=Peer, control=Control, list=List} = State) ->
%% The meat of the whole project: process a function call and return
%% the data
try erlang:binary_to_term(Data) of
{{CallType,M,F,A}, Caller} when CallType =:= call; CallType =:= async_call ->
{ModVsnAllowed, RealM} = check_module_version_compat(M),
case check_if_module_allowed(RealM, Control, List) of
true ->
case ModVsnAllowed of
true ->
WorkerPid = erlang:spawn(?MODULE, call_worker, [CallType, RealM, F, A, Caller, Socket, Driver, DriverMod]),
?log(debug, "event=call_received driver=~s socket=\"~s\" peer=\"~s\" caller=\"~p\" worker_pid=\"~p\"",
[Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Caller, WorkerPid]),
{keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
false ->
?log(debug, "event=incompatible_module_version driver=~s socket=\"~s\" method=~s module=~s",
[Driver, gen_rpc_helper:socket_to_string(Socket), CallType, RealM]),
waiting_for_data(info, {CallType, Caller, {badrpc,incompatible}}, State)
end;
false ->
?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s module=~s",
[Driver, gen_rpc_helper:socket_to_string(Socket), Control, CallType, RealM]),
waiting_for_data(info, {CallType, Caller, {badrpc,unauthorized}}, State)
end;
{cast, _M, _F, _A} = Cast ->
handle_cast(Cast, State),
{keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
BatchCast when is_list(BatchCast) ->
[handle_cast(Cast, State) || Cast <- BatchCast],
{keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
{abcast, Name, Msg} ->
_Result = case check_if_module_allowed(erlang, Control, List) of
true ->
?log(debug, "event=abcast_received driver=~s socket=\"~s\" peer=\"~s\" process=~s message=\"~p\"",
[Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Name, Msg]),
Msg = erlang:send(Name, Msg);
false ->
?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s",
[Driver, gen_rpc_helper:socket_to_string(Socket), Control, abcast])
end,
{keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
{sbcast, Name, Msg, Caller} ->
Reply = case check_if_module_allowed(erlang, Control, List) of
true ->
?log(debug, "event=sbcast_received driver=~s socket=\"~s\" peer=\"~s\" process=~s message=\"~p\"",
[Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Name, Msg]),
case erlang:whereis(Name) of
undefined -> error;
Pid -> Msg = erlang:send(Pid, Msg), success
end;
false ->
?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s",
[Driver, gen_rpc_helper:socket_to_string(Socket), Control, sbcast]),
error
end,
waiting_for_data(info, {sbcast, Caller, Reply}, State);
ping ->
?log(debug, "event=ping_received driver=~s socket=\"~s\" peer=\"~s\" action=ignore",
[Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer)]),
{keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
OtherData ->
?log(debug, "event=erroneous_data_received driver=~s socket=\"~s\" peer=\"~s\" data=\"~p\"",
[Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), OtherData]),
{stop, {badrpc,erroneous_data}, State}
catch
error:badarg ->
{stop, {badtcp,corrupt_data}, State}
end;
%% Handle the inactivity timeout gracefully
waiting_for_data(timeout, _Undefined, #state{socket=Socket, driver=Driver} = State) ->
?log(info, "message=timeout event=server_inactivity_timeout driver=~s socket=\"~s\" action=stopping",
[Driver, gen_rpc_helper:socket_to_string(Socket)]),
{stop, normal, State};
waiting_for_data(info, {DriverClosed, Socket} = Msg, #state{socket=Socket, driver_closed=DriverClosed} = State) ->
handle_event(info, Msg, waiting_for_data, State);
waiting_for_data(info, {DriverError, Socket, _Reason} = Msg, #state{socket=Socket, driver_error=DriverError} = State) ->
handle_event(info, Msg, waiting_for_data, State).Срочно требуется учитель литературы, чтобы объяснить, что хотел сказать автор.
CHayT,
22 Октября 2021
0
make_process_name("client", {Node,Key}) when is_atom(Node) ->
%% This function is going to be called enough to warrant a less pretty
%% process name in order to avoid calling costly functions
KeyStr = erlang:integer_to_list(erlang:phash2(Key)),
NodeStr = erlang:atom_to_list(Node),
erlang:list_to_atom("gen_rpc.client." ++ NodeStr ++ "/" ++ KeyStr);Самый страшный грех, который только возможен в Erlang.
CHayT,
22 Октября 2021
Follow us!