Philogy

from math import sqrt


def dy(c: float, l: float, u: float) -> float:
    if c < l:
        return 0
    if l <= c < u:
        return sqrt(c) - sqrt(l)
    return sqrt(u) - sqrt(l)

Philogy

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {ICurtaGolf} from "curta-golf/src/interfaces/ICurtaGolf.sol";
import {ICourse} from "curta-golf/src/interfaces/ICourse.sol";
import {IERC721} from "./interfaces/IERC721.sol";
import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
import {SafeCastLib} from "solady/utils/SafeCastLib.sol";

/// @author philogy <https://github.com/philogy>

Philogy

from attrs import define


@define
class Tick:
    fee_growth_outside: int

    def cross(self, fee_growth_global: int):
        self.fee_growth_outside = fee_growth_global - self.fee_growth_outside

Philogy

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {Script} from "forge-std/Script.sol";
import {Test} from "forge-std/Test.sol";
import {console2 as console} from "forge-std/console2.sol";

contract Counter {
    uint256 public count;

Philogy

(defn _double [:uint256 x] :uint256 [:internal :pure]
      (* x 2))

(defn add [:uint256 x] :uint256 [:external :pure]
      (if (< x 10) 0 (self/_double x)))

Philogy

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple EIP-6909 for IDs that are solely non-fungible.
/// @author Forked from Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC6909.sol)
/// @author philogy <https://github.com/philogy>
///
/// @dev Note:
/// The ERC6909 standard allows minting and transferring to and from the zero address,
/// minting and transferring zero tokens, as well as self-approvals.

Philogy

// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;

/// @author philogy <https://github.com/philogy>
contract Proxy {
    uint256 internal constant IMPL_SLOT = uint256(keccak256("eip1967.proxy.implementation")) - 1;
    uint256 internal constant ADMIN_SLOT = uint256(keccak256("eip1967.proxy.admin")) - 1;

    address[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff] internal slots;

Philogy

struct MyQueue {
    queue: Vec<i32>,
    stack: Vec<i32>,
}

/**
 * `&self` means the method takes an immutable reference.
 * If you need a mutable reference, change it to `&mut self` instead.
 */
impl MyQueue {

Philogy

def frange(start, end=None, step=None):
    assert (end is None) <= (step is None)
    if end is None:
        start, end, step = 0, start, 1
    elif step is None:
        step = 1
    assert step != 0
    sign = -1 if step < 0 else 1
    v = start
    while v * sign < end * sign:

Philogy

use std::cmp::{Ordering, PartialOrd};
use std::fs;

#[derive(Debug, PartialEq, Eq, Clone)]
enum Move {
    Rock,
    Paper,
    Scissors,
}