1,078 skills found · Page 26 of 36
eric-hs-rou / Fractional AF GeneratorSimulation codes to generate the fractionally-interpolated ambiguity function cuts of general discrete-time waveforms, as presented in the article: "Normalized Ambiguity Function Characteristics of OFDM, OTFS, AFDM, and CP-AFDM for ISAC" submitted to the IEEE ICC 2026.
mikechiloane / Payfast SDK Example UiThis is an example implementation of the PayFast Java SDK. The UI interacts with a Lambda function that uses the PayFast Java SDK to generate the PayFast form data.
MinfonTsai / SHA256 EmbeddedSHA-256 cryptographic hash algorithm generates is one way and cannot be decrypted back. This makes it suitable for password validation, blockchain, anti-tamper, digital signatures. SHA-256 is one of the successor hash functions to SHA-1, and is one of the strongest hash functions available.
jack0915 / PWM Fan ControllerA smart fan controller use a STM32 MCU to cooling a LED light . The controller have 3 main function. 1.A GPIO generate a 25KHz PWM signal to control the fan speed. 2.The fan speed increase with temperature increasing. 3.When the temperature over 80 degress celsius, a buzzer sound. When the tmeperature over 100 degress celsius, the LED light power will be cut off
HitAgain / Virtual Person Posture Rotation Representation And Loss Calculation ToolThis is my internship project in NetEase game AI Lab: multi-modal virtual human interaction, through the text to predict the virtual human action and then generate animation through Unity rendering, enhance the interactive experience of virtual characters. This is the calculation tool I used to refer to the Python version written independently by the relevant C code, including quaternions, rotation vectors, Euler angles, and the loss function between the predicted rotation and the true rotation. This part I listed separately as a calculation tool for everyone to use in the game AI experiment development process. QuartClass is a class that integrates all functions. I have tested all the features and it is stable and feasible.
basta1255s / Owntoken.solSkip to content Why GitHub? Team Enterprise Explore Marketplace Pricing Search Sign in Sign up safemoonprotocol / Safemoon.sol 476618 Code Issues 62 Pull requests 4 Actions Projects Wiki Security Insights Safemoon.sol/Safemoon.sol @safemoonprotocol safemoonprotocol Create Safemoon.sol Latest commit 152e907 on Mar 4 History 1 contributor 1166 lines (997 sloc) 42.3 KB /** *Submitted for verification at BscScan.com on 2021-03-01 */ /** *Submitted for verification at BscScan.com on 2021-03-01 */ /** #BEE #LIQ+#RFI+#SHIB+#DOGE = #BEE #SAFEMOON features: 3% fee auto add to the liquidity pool to locked forever when selling 2% fee auto distribute to all holders I created a black hole so #Bee token will deflate itself in supply with every transaction 50% Supply is burned at start. */ pragma solidity ^0.6.12; // SPDX-License-Identifier: Unlicensed interface IERC20 { function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } function geUnlockTime() public view returns (uint256) { return _lockTime; } //Locks the contract for owner for the amount of time provided function lock(uint256 time) public virtual onlyOwner { _previousOwner = _owner; _owner = address(0); _lockTime = now + time; emit OwnershipTransferred(_owner, address(0)); } //Unlocks the contract for owner when _lockTime is exceeds function unlock() public virtual { require(_previousOwner == msg.sender, "You don't have permission to unlock"); require(now > _lockTime , "Contract is locked until 7 days"); emit OwnershipTransferred(_owner, _previousOwner); _owner = _previousOwner; } } // pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } // pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } // pragma solidity >=0.6.2; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } contract SafeMoon is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000000000 * 10**6 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = "SafeMoon"; string private _symbol = "SAFEMOON"; uint8 private _decimals = 9; uint256 public _taxFee = 5; uint256 private _previousTaxFee = _taxFee; uint256 public _liquidityFee = 5; uint256 private _previousLiquidityFee = _liquidityFee; IUniswapV2Router02 public immutable uniswapV2Router; address public immutable uniswapV2Pair; bool inSwapAndLiquify; bool public swapAndLiquifyEnabled = true; uint256 public _maxTxAmount = 5000000 * 10**6 * 10**9; uint256 private numTokensSellToAddToLiquidity = 500000 * 10**6 * 10**9; event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap); event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor () public { _rOwned[_msgSender()] = _rTotal; IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F); // Create a uniswap pair for this new token uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH()); // set the rest of the contract variables uniswapV2Router = _uniswapV2Router; //exclude owner and this contract from fee _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeFromReward(address account) public onlyOwner() { // require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeInReward(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setTaxFeePercent(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() { _liquidityFee = liquidityFee; } function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() { _maxTxAmount = _tTotal.mul(maxTxPercent).div( 10**2 ); } function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } //to recieve ETH from uniswapV2Router when swaping receive() external payable {} function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate()); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity); } function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) { uint256 tFee = calculateTaxFee(tAmount); uint256 tLiquidity = calculateLiquidityFee(tAmount); uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity); return (tTransferAmount, tFee, tLiquidity); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rLiquidity = tLiquidity.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _takeLiquidity(uint256 tLiquidity) private { uint256 currentRate = _getRate(); uint256 rLiquidity = tLiquidity.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity); if(_isExcluded[address(this)]) _tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity); } function calculateTaxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_taxFee).div( 10**2 ); } function calculateLiquidityFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_liquidityFee).div( 10**2 ); } function removeAllFee() private { if(_taxFee == 0 && _liquidityFee == 0) return; _previousTaxFee = _taxFee; _previousLiquidityFee = _liquidityFee; _taxFee = 0; _liquidityFee = 0; } function restoreAllFee() private { _taxFee = _previousTaxFee; _liquidityFee = _previousLiquidityFee; } function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer( address from, address to, uint256 amount ) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if(from != owner() && to != owner()) require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount."); // is the token balance of this contract address over the min number of // tokens that we need to initiate a swap + liquidity lock? // also, don't get caught in a circular liquidity event. // also, don't swap & liquify if sender is uniswap pair. uint256 contractTokenBalance = balanceOf(address(this)); if(contractTokenBalance >= _maxTxAmount) { contractTokenBalance = _maxTxAmount; } bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity; if ( overMinTokenBalance && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled ) { contractTokenBalance = numTokensSellToAddToLiquidity; //add liquidity swapAndLiquify(contractTokenBalance); } //indicates if fee should be deducted from transfer bool takeFee = true; //if any account belongs to _isExcludedFromFee account then remove the fee if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){ takeFee = false; } //transfer amount, it will take tax, burn, liquidity fee _tokenTransfer(from,to,amount,takeFee); } function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { // split the contract balance into halves uint256 half = contractTokenBalance.div(2); uint256 otherHalf = contractTokenBalance.sub(half); // capture the contract's current ETH balance. // this is so that we can capture exactly the amount of ETH that the // swap creates, and not make the liquidity event include any ETH that // has been manually sent to the contract uint256 initialBalance = address(this).balance; // swap tokens for ETH swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered // how much ETH did we just swap into? uint256 newBalance = address(this).balance.sub(initialBalance); // add liquidity to uniswap addLiquidity(otherHalf, newBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { // approve token transfer to cover all possible scenarios _approve(address(this), address(uniswapV2Router), tokenAmount); // add the liquidity uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable owner(), block.timestamp ); } //this method is responsible for taking all fee, if takeFee is true function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private { if(!takeFee) removeAllFee(); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } if(!takeFee) restoreAllFee(); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } } © 2021 GitHub, Inc. Terms Privacy Security Status Docs Contact GitHub Pricing API Training Blog About
ntotorica / SMP Passivity EnforcementAuthor: Nathan Totorica Date: 5/14/2021 # Singularity Matrix Pertubation (SMP) This code was written for a class project in the course entitled ECE 504: "ST: Passive Electromagnetic Systems" taught in Spring 2021 by Dr. Ata Zadehgol at the University of Idaho in Moscow. This code was developed, in part, based on the code developed by Jennifer Houle in ECE 504 "ST: Modern Circuit Synthesis Algorithms" taught in Spring 2020 by Dr. Ata Zadehgol. Jennifer's code is available online at https://github.com/JenniferEHoule/Circuit_Synthesis. ## Overview Singular Matrix Perturbation (SMP) as introduced in [11], is a passivity enforcement algorithm for use on fitted models. This robust method is fast, computationally inexpensive, and accurate in enforcing passivity. This implementation using Python can easily be used with Vector Fitting algorithm implemented in [12]. Example cases to demonstrate passivity enforcmment were taken from [7][15], as well as custom examples designed in simulation software based off of multiport circuit synthesis as described in [6]. ## I/O and Flow Description - Instructions for input and output and flow description can be found in flow_diagram.pdf. ## Files - SMP.py: Singularity matrix perturbation implementation of [11] - s_compare.py: Compare ADS simulated S matrices. Calculate RMS error and plot - eig_plot.py: Plotting functions. Eigenvalue plots based off of plot.py in [12] - smp_ex.py: Example of how to pull .sp file in, parse parameters, send to vector fitting, enforce passivity, and generate new passive circuit. Imported from [12] - Ex2_y.py - vectfit3.py - intercheig.py - rot.py - pass_check.py - fitcalc.py - FRPY.py - intercheig.py - violextrema.py - plots.py - quadprog.py - pr2ss.py - utils.py ## Licensing GPL-3.0 License In addition to licensing: Embedding any of (or parts from) the routines of the Matrix Fitting Toolbox in a commercial software, or a software requiring licensing, is strictly prohibited. This applies to all routines, see Section 2.1. If the code is used in a scientific work, then reference should me made as follows: VFdriver.m and/or vectfit3.m: References [1],[2],[3] RPdriver.m and/or FRPY.m applied to Y-parameters: [8],[9] ## References [1] B. Gustavsen and A. Semlyen, "Rational approximation of frequency domain responses by Vector Fitting", IEEE Trans. Power Delivery, vol. 14, no. 3, pp. 1052-1061, July 1999. [2] B. Gustavsen, "Improving the pole relocating properties of vector fitting", IEEE Trans. Power Delivery, vol. 21, no. 3, pp. 1587-1592, July 2006. [3] D. Deschrijver, M. Mrozowski, T. Dhaene, and D. De Zutter, "Macromodeling of Multiport Systems Using a Fast Implementation of the Vector Fitting Method", IEEE Microwave and Wireless Components Letters, vol. 18, no. 6, pp. 383-385, June 2008. [4] B. Gustavsen, VFIT3, The Vector Fitting Website. March 20, 2013. Accessed on: Jan. 21, 2020. [Online]. Available: https://www.sintef.no/projectweb/vectfit/downloads/vfit3/. [5] A. Zadehgol, "A semi-analytic and cellular approach to rational system characterization through equivalent circuits", Wiley IJNM, 2015. [Online]. https://doi.org/10.1002/jnm.2119 [6] V. Avula and A. Zadehgol, "A Novel Method for Equivalent Circuit Synthesis from Frequency Response of Multi-port Networks", EMC EUR, pp. 79-84, 2016. [Online]. Available: ://WOS:000392194100012. [7] B. Gustavsen, Matrix Fitting Toolbox, The Vector Fitting Website. March 20, 2013. Accessed on: Feb. 25, 2020. [Online]. Available: https://www.sintef.no/projectweb/vectorfitting/downloads/matrix-fitting-toolbox/. [8] B. Gustavsen, "Fast passivity enforcement for S-parameter models by perturbation of residue matrix eigenvalues", IEEE Trans. Advanced Packaging, vol. 33, no. 1, pp. 257-265, Feb. 2010. [9] B. Gustavsen, "Fast Passivity Enforcement for Pole-Residue Models by Perturbation of Residue Matrix Eigenvalues", IEEE Trans. Power Delivery, vol. 23, no. 4, pp. 2278-2285, Oct. 2008. [10] A. Semlyen, B. Gustavsen, "A Half-Size Singularity Test Matrix for Fast and Reliable Passivity Assessment of Rational Models," IEEE Trans. Power Delivery, vol. 24, no. 1, pp. 345-351, Jan. 2009. [11] E. Medina, A. Ramirez, J. Morales and K. Sheshyekani, "Passivity Enforcement of FDNEs via Perturbation of Singularity Test Matrix," in IEEE Transactions on Power Delivery, vol. 35, no. 4, pp. 1648-1655, Aug. 2020, doi: 10.1109/TPWRD.2019.2949216. [12] Houle, Jennifer, GitHub. May 10, 2020. Accessed on: February 3, 2021. [Online]. Available: https://github.com/jenniferEhoule/circuit_synthesis
JoyceQuinn / Best Advertising And Marketing ManagementAs a digital marketing company, we have actually driven numerous web site hits, millions of leads as well as also millions of sales. So if you are a local business or a young expert that wants to find out more about marketing management, then you remain in the best place. Today, we're reviewing exactly how advertising managers can develop effective projects, detailed. Our digital marketing firm saves small companies from bad advertising as well as no development, yet of course, in order to do that effectively, our advertising and marketing supervisors have to have extraordinary skills around marketing monitoring. Regrettably, a great deal of the schools today are instructing out-of-date advertising and marketing techniques. As well as the net is swamped with phony experts who show marketing however in fact have no actual experience. This can be an easy catch for anyone just beginning to seek aid regarding the globe of marketing. That's why you should pick up from individuals who have actual experience As Well As can confirm it for greater than one firm. And also these are simply results we've gotten for our firm, using our very own techniques. We have more than 10,000 hrs of actual digital marketing experience and also have aided thousands of business find the very best options to their advertising issues. Just how have we managed to do this? Via our team of marketer! In order for them to offer these efficient options, our marketing supervisors need to have outstanding abilities around marketing administration. And those abilities are precisely what our advertising and marketing supervisors have. We're mosting likely to give you some powerful techniques if you want to learn advertising and marketing monitoring or become a much better marketing manager. In this blog, you will certainly learn exactly how advertising managers can develop effective campaigns, step-by-step. We will certainly discuss: 1. Just how to onboard a brand-new marketing project 2. Just how to structure your strategy 3. How to setup everything 4. And much more! Without further trouble, let's go ahead as well as dive in with action # 1. Action 1: How to onboard a brand-new advertising project Whether you are beginning a new marketing campaign from square one or you are inheriting an existing advertising campaign, it is really important to recognize 2 things. # 1 You require to develop your advertising goals. Now usually we have clients that will certainly claim their objective is to obtain more sales. Yet that is an extremely high-level goal. With that, you'll intend to unbox your goal into something more workable. To break down your objective into actionable parts, we will certainly start to speak about leading as well as lagging indicators. A lagging indicator is normally a result, such as more sales, even more leads, or more web traffic, which are great objectives to have. Yet in order to get to an outcome or a lagging indication, you need a leading indication which is typically an action. Leading signs are points that you can regulate now everyday or each week. And these are the advertising and marketing objectives that you want to develop. As a marketing manager, you need to understand both leading and lagging objectives. # 2 You need to understand your budget. When you onboard an advertising and marketing campaign, you require to understand your campaign budget. If you are unclear about your marketing spending plan or about just how to accurately calculate your marketing budget, we have a thorough video clip that can help you here. Ultimately, the important point below is that you intend to make sure your budget plan matches your objectives. For that reason, if you desire $1 million in sales for instance, then you require to be all set to spend thousands of thousands of dollars. And also honestly, you wish to be as sensible as possible because that's the accountable thing to do as a great online marketer. A lot of people strive for the over night success desire, however the fact is excellent marketing can require time. Now that you have established you require to establish some advertising goals and also a spending plan, after that you can transfer to tip number two, which is "just how to structure your advertising strategy." Action 2: Exactly how to structure your advertising plan The first thing we suggest that you do is to develop an advertising and marketing channel, or really plainly recognize the advertising and marketing channel that already exists. If your business is already generating any type of sales, after that you likely have an advertising and marketing channel whether you understand it or not. It is necessary to recognize which part of the funnel you will certainly need to influence with your advertising project. Understanding the advertising channel will help you pinpoint which stage of the channel demands adjustments. To get a far better understanding of the advertising and marketing channel, let's take a more detailed look at an advertising funnel as well as break down an advertising funnel for B2C (service to customer) as well as B2B (organization to service) firms. At the top of the channel you have the recognition stage. For both B2B or B2C companies this is where potential consumers become aware of your company either by means of search, or an advertisement, or a person referring them to you. The next part of the channel is the interest stage. This is where your capacity clients start to read more concerning your product and services. After that phase of the channel is the consideration stage. This is where your capacity customers actually begin thinking about buying your products. They might begin to review your evaluations or compare your products to others that are on the market. After the consideration stage is the intent phase. This is the stage where the potential client prepares to buy as well as simply needs a little push to complete the transaction. If you're a B2C firm, that implies that a visitor has perhaps added something to their cart. And also if you're a B2B firm, that implies that a site visitor may have asked for a meeting or a live trial. Swiftly after that, the prospective consumer enters the examination stage. This is when the potential consumer is considering the experience they are having as they are having a look at for a B2C company or finishing the contract for a B2B firm. At the really bottom of the channel you have the actual purchase, which is when the potential client becomes a real consumer. As you can see, there is a whole process to getting a client to really end up being a client. On top of that, a channel can continue after the acquisition factor, particularly if you wish to get even more sales from your present consumers. However those phases we pointed out are mosting likely to be the major locations that the majority of marketing managers require to focus on. Nevertheless, if you wish to discover a bit a lot more concerning marketing funnels, check out this blog where we go a lot more thorough with the advertising and marketing channel phases. As you are doing your marketing administration, you wish to begin asking on your own, "Which stage in the advertising and marketing channel does my organization require the most assist with?" You will discover that some business require general understanding prior to they can enhance any other part of their funnel. You may additionally locate that some business have a lot of awareness, yet battle to convert those introduce sales. However, once you recognize where your marketing needs one of the most aid, then you can concentrate there and also start to establish those leading indication objectives. For example, in the recognition stage, you have to focus on getting to a great deal of people. And also if business spending plan you have actually established is reduced, that suggests you will likely require to make use of an organic advertising and marketing approach. Currently let's move on to tip number three, which is just how to establish your advertising and marketing projects Action 3: How to set up your marketing campaigns. The first thing you need to think of below is production. What we indicate by "production" is you need to understand WHO or WHAT you require and WHEN you require it. To figure this out, go back to your leading indications and think about just how you are mosting likely to complete them. Possibly you need a web content writer, a designer, or a marketing spending plan. Or perhaps you require to set aside a couple of hours a day, to hire an agency, or a few other tools to aid you be reliable. The bottom line is, you need to be extremely clear about what deliverables you need as well as when you require them. After manufacturing, we recommend that you track your development. Since doesn't mean you are seeking that delayed indication or that major result that you wish to accomplish. Rather, you'll want to track whether or not your growth is headed in a positive instructions. Ideally, it's very easy to determine a trend line that is going up overtime. For example, if you are publishing on YouTube on a daily basis for six months as well as you are not obtaining any kind of sights whatsoever, then that is an indication that you require to quit and reassess your advertising strategy. One of our company's favorite tools to make use of to track development is Google Analytics. It's very simple to set up on your own as well as ought to take you no time to obtain arrangement and start. As soon as you're set up for success with Google Analytics, you can go on to tip number four, which isn't truly an action however it is a crucial idea to live by. Step 4: Stay with your strategy We have actually stated it before however excellent advertising takes some time. We can't emphasize this sufficient. Unless you have a really large spending plan, we're speaking at the very least $100,000 a year, then you greater than likely will require to focus on one point at a time. That means you wish to put together a really great approach and make sure it functions PRIOR TO you proceed to something that is new and also stylish right now. We suggest you give your technique a minimum of 6 months before you quit. And this is six months of pure quality! That means you are not missing out on due dates and you are putting together an excellent amount of quantity and also top quality work. Bear in mind to still be tracking your outcomes and making sure you're constructing some energy or seeing a positive trend line. Even if the positive trend line is slow, it is still positive. Now allow's go on to our last step. Tip 5: Reporting If you are doing any type of type of advertising and marketing management or if you are an advertising and marketing supervisor on your own, after that at some time you will require to do some reporting. Whether you are reporting to yourself, stakeholders, a supervisor, or a customer, this is an area where you require to successfully interact just how your advertising and marketing is going. When you are connecting, you need to recognize your target market. If you are speaking to an additional advertising and marketing professional or somebody with an advertising background, after that you can possibly utilize more advanced descriptions of your development. However if you are speaking with someone that does not know a lot regarding advertising, after that you want to try to simplify as simply as possible. For instance, you would not begin speaking to a stranger about ROAS, ROI, conversion projects, as well as lead-to-sale conversions since there's a slim chance they would understand what you were discussing. Everything that we cover in this blog are points that you wish to communicate to whoever you are reporting to. To make sure that suggests you want to relate things back to the goals, the budget, the channel, and the positive pattern line. You'll see that poor marketing professionals only care about telling you just how good their negative results are. A bad marketing professional will tell you about all the leads they have actually created but have really little results for conversions. As good marketers, it is our obligation to interact successfully as well as with honesty. So understand your numbers, know your target market, as well as be as clear as possible whether the results are good or bad. Establishing in-depth records that are comprehensive sufficient for your audience to recognize is what will assist everyone be on the very same web page. Verdict There you have it-- 5 truly awesome suggestions for advertising monitoring. Tips that we stand by and are confirmed due to the fact that we've used them for our own advertising and marketing projects. In addition, we have actually managed campaigns for our customers that have actually driven numerous hits, numerous leads, and countless sales. That's why we believe you can stand by these important pointers we have actually supplied here.And there's so much extra you can learn more about advertising and marketing for your business! Whether you are a small company proprietor or a young specialist that intends to find out more concerning advertising and marketing administration, after that you remain in the right area. Our group of marketer prepare to help you make on your own a better marketer!
jokergoo / GlobalOptionsGenerate function to get or set global options
alfonsosaera / MyManhattanR function to generate Manhattan plots using ggplot
KangarooBox / Lambda Cloudwatch Event MsteamsAn AWS Lambda function for better MS Teams notifications generated from CloudWatch events.
clumsycomputer / Clumsy Wavfunctions for generating .wav file data 🔉
MathisWellmann / Go Timeseries GeneratorGenerate common timeseries using Go. Used mostly for testing filter functions or other technical analysis indicators
immanelg / SicliGenerate CLI parsers from typed functions
rustinqi / Threejs Text SpriteFunction for generating multi-line text sprite for Three.js.
lpil / Glue🩹 Generate functions from your Gleam code!
giftDad / Protoc Gen Validategenerate validation function for every proto message
TeamHypersomnia / Introspector GeneratorA utility for C++ generating introspector functions from comments in the code.
styd / Functionable JsonGenerate JSON with JavaScript functions from ruby hash
malob / Serverless Tts PodcastWIP rewrite of article-to-audio-cloud-function and generate-podcast-rss-cloud-function
